diff --git a/README.md b/README.md index 4f7965c..57e662a 100644 --- a/README.md +++ b/README.md @@ -7,10 +7,9 @@ Original preprint: https://doi.org/10.1101/2021.09.03.458628 # Usage examples -The following notebook contains usage examples of DPAD for several use-cases: -[source/DPAD/example/DPAD_tutorial.ipynb](https://github.dev/ShanechiLab/DPAD/blob/main/source/DPAD/example/DPAD_tutorial.ipynb). - -An HTML version of the notebook is also available next to it in the same directory. +The following notebooks contains usage examples of DPAD for several use-cases: +1. Simulation notebook: [source/DPAD/example/DPAD_tutorial.ipynb](https://github.dev/ShanechiLab/DPAD/blob/main/source/DPAD/example/DPAD_tutorial.ipynb). +2. Notebook with real neural-behavioral data: [source/DPAD/example/DPAD_tutorial2.ipynb](https://github.dev/ShanechiLab/DPAD/blob/main/source/DPAD/example/DPAD_tutorial2.ipynb). # Usage examples The following documents explain the formulation of the key classes that are used to implement DPAD (the code for these key classes is also available in the same directory): diff --git a/source/DPAD/example/DPAD_tutorial2.ipynb b/source/DPAD/example/DPAD_tutorial2.ipynb new file mode 100644 index 0000000..2d5985e --- /dev/null +++ b/source/DPAD/example/DPAD_tutorial2.ipynb @@ -0,0 +1,16000 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " Written by: Omid G. Sani and Parsa Vahidi\n", + "\n", + " Last update: June, 2025" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " # DPAD Tutorial\n", + "\n", + "\n", + "## **TLDR**\n", + "In this notebook, we provide step by step explanations and examples for applying DPAD to real neural-behavioral data. At the end of the day, your code for running DPAD will look something like the following code block. However, **please make sure to look at the sections below, *especially the FAQ section*, for tips on how to determine appropriate hyperparameters for your use-case**.\n", + "\n", + "```python\n", + "methodCode = \"DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\" # Defines search space over nonlinearities by flexible DPAD\n", + "selectedMethodCode, iCVRes = fitDPADWithFlexibleNonlinearity(yTrain, Z=zTrain, nx=nx, n1=n1, settings={}, methodCode=methodCode, saveDir=saveDir) # Fits DPAD with desired nonlinearities and selects the best performing option within training data\n", + "\n", + "idSysF = DPADModel()\n", + "args = DPADModel.prepare_args(selectedMethodCode) # Get arguments needed for fitting DPAD with selected configuration\n", + "idSysF.fit(yTrain.T, Z=zTrain.T, nx=nx, n1=n1, epochs=epochs, **args) # Fit final model\n", + "\n", + "zTestPredF, yTestPredF, xTestPredF = idSysF.predict(yTest) # Run inference to generate predictions\n", + "```\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " \n", + "\n", + " ## Overview \n", + " DPAD, which stands for **Dissociative and Prioritized Analysis of Dynamics**, is a method for nonlinear dynamical modeling of time-series neural-behavioral data that can simultaneously model, dissociate, and prioritize behaviorally relevant neural dynamics and can test hypotheses about the origin of nonlinearity. Beyond neural-behavioral data, DPAD can also be applied to any other two time-series data to simultaneously model, dissociate, and prioritize their shared dynamics. In this notebook, we will demonstrate how to use DPAD in two different modes: 1) Flexible nonlinearity (recommended) 2) User-defined nonlinearity. We then provide complete examples of applying DPAD to a real dataset analyzed in the paper. For more details on the methods and for results in multiple real neural datasets, please see the DPAD paper:\n", + "\n", + " Omid G. Sani, Bijan Pesaran, Maryam M. Shanechi. *Dissociative and prioritized modeling of behaviorally relevant neural dynamics using recurrent neural networks*. ***Nature Neuroscience*** (2024). https://doi.org/10.1038/s41593-024-01731-2\n", + "\n", + " Original preprint: https://doi.org/10.1101/2021.09.03.458628\n", + "\n", + " ## Model\n", + " Given signals $y_k$ (e.g. neural signals) and $z_k$ (e.g. behavior), DPAD learns a dynamic model for $y_k$ while prioritizing the dynamics that are relevant to $z_k$. The DPAD model can be formulated as (Eq. 1 in the [DPAD paper](https://doi.org/10.1038/s41593-024-01731-2)):\n", + "\n", + " $$ x_{k+1} = A'(x_k) + K(y_k) $$\n", + "\n", + " $$ y_k = C_y(x_k) + e_k $$\n", + "\n", + " $$ z_k = C_z(x_k) + \\epsilon_k $$\n", + "\n", + " Multi-input multi-output functions $A'$ (recursion), $K$ (neural input), $C_y$ (neural readout), and $C_z$ (behavior readout) define the model. DPAD with flexible nonlinearity can automatically fit all these nonlinearities to best describe the training data. Further, DPAD allows the user to flexibly set any of these four parameters to be linear or nonlinear. As such, it also enables testing hypotheses about where the origin of nonlinearities is in the dynamical transformation of neural activity to behavior (use-case 4 in the [DPAD paper](https://doi.org/10.1038/s41593-024-01731-2))." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using DPAD\n", + "\n", + "DPAD provides two ways of modeling data as follows. We expand on how to use each approach in the latter sections:\n", + "\n", + "1) ***Flexible DPAD*** (recommended): This is the recommended way of using DPAD. Flexible DPAD first automatically searches for the most optimal nonlinearity configuration given the dataset. Running flexible DPAD has 2 steps:\n", + "\n", + " 1.1) First, perform an inner cross-validation within training data to select the optimal nonlinearity.\n", + "\n", + " 1.2) Second, with the selected optimal nonlinearity obtained by step 1.1, train a DPAD model on the entire training dataset in the user-defined mode explained below (approach 2).\n", + "\n", + " More details on flexible DPAD can be found in [DPAD paper](https://doi.org/10.1038/s41593-024-01731-2). **Please refer to the latter section entitled `Modeling of neural-behavioral data: Flexible DPAD` for a complete example applied to real neural-behavioral data**.\n", + "\n", + "2) ***DPAD with user-defined nonlinearity***: Using this approach, the user can select the DPAD transformations they want to be nonlinear. This is useful for:\n", + " \n", + " - **(a)** Faster tests of each desired nonlinearity.\n", + " - **(b)** Cases where the source of nonlinearity is known (e.g., as the second part of flexible DPAD (1.2 in the above) after the optimal nonlinearity is selected, or in simulations where the ground truth nonlinearity is known). \n", + " \n", + "\n", + "\n", + " Note that to leverage DPAD's full capacity, one should use the flexible DPAD to determine the optimal nonlinearity configuration. This is specifically the case as the optimal nonlinearity configuration is, in general, dataset-specific.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 1. Flexible DPAD\n", + "\n", + "Here we explain the steps for running flexible DPAD. Please refer to section `Modeling of neural-behavioral data: Flexible DPAD` for a full example applied to real data.\n", + "\n", + "### 1.1. Selecting the nonlinearity that best fits the data\n", + "The function `fitDPADWithFlexibleNonlinearity` searches over possible nonlinearities and picks the best one based on the training data.\n", + "\n", + "First, set the number of cores required to parallelize the run:\n", + "\n", + "```python\n", + "settings = {}\n", + "settings[\"min_cores_to_enable_parallelization\"] = 100 # If fewer than this many cores are available, code will not run with parallelization, set to a large number to disable parallelization\n", + "```\n", + "This should be smaller than the total number of cores your machine has, and even then, depending on available memory and machine specs, parallel runs may lead to the OS freezing. If that happens, to disable parallelization completely, set `min_cores_to_enable_parallelization` to a number larger than the number of cores than the machine has (e.g. you can set it to 1000). \n", + "\n", + "\n", + "Then set the `methodCode` to define the search space for flexible DPAD:\n", + "```python\n", + "methodCode = \"DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\" # `1HL64U` specifies that each nonlinear parameter will be an MLP with zeros (linear) or 1 hidden layer, each hidden layer including 64 hidden units (for the 1 hidden layer case).\n", + "```\n", + "The above methodCode searches over this space: \n", + "Each parameter will be linear (0 hidden layer), or MLP with 1 hidden layer. In case of nonlinreaity, hidden layer with 64 hidden units are tried. 4 parameters $(A'/K/C_y/C_z)$ => $2^4=16$ cases searched.\n", + "\n", + "Here is a more detailed explanation of the methodCode:\n", + "- 'GSUT_iCVF4': Include to perform search over possible nonlinearities with a 4-fold inner cross-validation. You can change the number of inner cross-validated fold by changing 4 to a smaller/larger number. To make the nonlinearity selection besed on best behavior ($z_k$) prediction, use 'GSUT' as in the default code above. Alternatively if want to select the nonlinearity with best neural ($y_k$) self-prediction, add 'y' at the end of 'GSUT' as: 'GSUT**y**_iCVF4'.\n", + "- 'uAKCzCy1HL64U': Defines the search space. Tries each of the four mappings ($A'$, $K$, $C_y$ and $C_z$) as linear or nonlinear (1 hidden layer & 64 units when nonlinear). 'uAK' (instead of just 'AK') means for the cases with both $A'$ and $K$ nonlinear, combine them into a single mapping. This is more general and is generally a good practice. Please refer to [DPAD paper](https://doi.org/10.1038/s41593-024-01731-2) for more details on this.\n", + "\n", + "\n", + "A few other useful things to add to the methodCode:\n", + "1) 'RTR2': Attempts fitting with two random parameter initializations and keeps the one that achieves a lower training loss.\n", + "2) 'ErSV16': Sets early stopping to 16 epochs based on an inner validation set (last 20% of the training data).\n", + "\n", + "Setting maximum number of epochs: \n", + "\n", + "settings['fit_epochs']: (default=2500) Sets the maximum number of epochs for training. Fitting will stop upon convergence or after at most the specified number of epochs. 2500 as the max number of epochs is usually more than enough. Default early stopping criteria is based on validation loss with 16 epochs patience (also encoded in the methodCode above as 'ErSV16'). Please read more on this in the FAQ section.\n", + "\n", + "\n", + "After preparing all input arguments, run the following to automatically train many alternative models with different nonlinearity settings and automatically select the best one for the specific data:\n", + "```python\n", + "selectedMethodCode, iCVRes = fitDPADWithFlexibleNonlinearity(\n", + " yTrain, Z=zTrain, nx=nx, n1=n1, settings=settings, methodCode=methodCode, saveDir=saveDir)\n", + "```\n", + "With the following arguments:\n", + "- `yTrain` and `zTrain`: Neural and behavioral training data, respectively. Dimensions are: time x data.\n", + "\n", + "- `nx`: The total dimension of the latent state in the model.\n", + "\n", + "- `n1`: The number of latent state dimensions that are going to be dedicated to behaviorally relevant neural dynamics.\n", + "\n", + "- `settings`: Additional settings as explained above.\n", + "\n", + "- `methodCode`: As explained above.\n", + "\n", + "- `saveDir`: Directory where you want the results to be saved.\n", + "\n", + "\n", + "Running the above function can be slow, depending on the size of data and search space. It ultimately outputs a string, i.e., `selectedMethodCode`, which is the method code for the nonlinearity that fits the data the best. Once we obtain that, we can train DPAD again with this optimal setting on entire training data as explained next under section 1.2. \n", + "\n", + "The inner cross-validated fitting results for all searched configurations, i.e., models, performance measures, etc are saved in `iCVRes` variable.\n", + "\n", + "\n", + "Typical runtime for this step:\n", + "- For any individual nonlinearity: a couple of minutes\n", + "- For flexible search over all nonlinearity options:\n", + " + Without parallelization: sum of run times for all considered nonlinearity options\n", + " + With full parallelization: max of run time across all considered nonlinearity options\n", + "\n", + "If you want to find the best fit for the data, running this `flexible` step is essential. Nevertheless, you can skip this step and decide what nonlinearity setting you want to use manually by specifying `selectedMethodCode`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2. Running DPAD with best nonlinearity selected in step 1.1\n", + "\n", + "**Note:** step 1.2. is essentially same as approach 2, i.e., running DPAD with user-defined nonlinearity except that the nonlinearity (and its corresponding `methodCode`) is selected by step 1.1. Regardless, we provide a complete explanation of running DPAD (and how to set the `methodCode`) for user-defined nonlinearity later under section `2. DPAD with user-defined nonlinearity`. \n", + "\n", + "We first need to import the DPADModel class and initialize it:\n", + "```python\n", + "from DPAD import DPADModel\n", + "idSys = DPADModel() # Initializing DPAD model\n", + "```\n", + "### Set nonlinearity as the optimal one obtained by step 1.1\n", + "We then set the methodCode as the code for the optimal nonlinearity (obtained in step 1.1 by running function `fitDPADWithFlexibleNonlinearity`):\n", + "\n", + "```python\n", + "methodCode = selectedMethodCode # This is the methodCode for the optimal nonlinearity selected in step 1.1.\n", + "```\n", + "To prepare the desired nonlinearity settings, DPAD uses a helper function called `DPADModel.prepare_args`. This function simply takes `methodCode` string as input and returns the relevant arguments to pass to `idSys.fit`. More on this in the next section where we explain `2. DPAD with user-defined nonlinearity`.\n", + "\n", + "```python\n", + "args = DPADModel.prepare_args(methodCode) \n", + "```\n", + "\n", + "### Train final DPAD model\n", + "After `args` are prepared by the `DPADModel.prepare_args` method, call `fit` to train DPAD model:\n", + "```python\n", + "idSys.fit(yTrain, zTrain, nx=nx, n1=n1, **args)\n", + "```\n", + "\n", + "With the following arguments:\n", + "- `yTrain` and `zTrain`: Neural (e.g. LFP signal powers or spike counts) and behavioral training data (e.g. joint angles, hand position, etc), respectively. Dimensions are: data x time.\n", + "\n", + "- `nx`: The total dimension of the latent state in the model.\n", + "\n", + "- `n1`: The number of latent state dimensions that are going to be dedicated to behaviorally relevant neural dynamics.\n", + "\n", + "- `args`: Other arguments that specify the type of nonlinearity in each parameter within the model (refer to the explanation for specifiying user-defined nonlinearity in section 2 below). Please check DPADModel.fit() arguments for more options. Please also see the FAQ #4: *Tips for avoiding optimization issues*.\n", + "\n", + "After running the above, the learned model will be stored in the `DPADModel` object called `idSys`.\n", + "\n", + "### Inference with learned model for state estimation, neural self-prediction and behavior decoding\n", + "\n", + "For a learned DPAD model `idSys` you can use the `predict` method to extract the latent state and predict behavior and neural activity given any new neural data as:\n", + "```python\n", + "zPred, yPred, xPred = idSys.predict(yTest)\n", + "```\n", + "With the argument:\n", + "- `yTest`: Neural activity `y` in the test data. Dimensions are: time x data dimension.\n", + "\n", + "And with outputs (all dimensions are time x data dimension):\n", + "- `zPred`: Prediction of behavior using past neural activity at each data point.\n", + "\n", + "- `yPred`: Prediction of neural activity using past neural activity at each data point.\n", + "\n", + "- `xPred`: The latent state extracted at each data point." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. DPAD with user-defined nonlinearity\n", + "Here we explain how to directly run DPAD with user-defined nonlinearity.\n", + "\n", + "To use DPAD in this mode, you first need to import the DPADModel class, for example by running:\n", + "```python\n", + "from DPAD import DPADModel\n", + "```\n", + "\n", + "You can then use it to model data as:\n", + "```python\n", + "idSys = DPADModel() # Initializing DPAD model\n", + "```\n", + "\n", + "### Define nonlinearity\n", + "To set the desired nonlinearity, DPAD uses a helper function called `DPADModel.prepare_args`. This function simply takes `methodCode` string as input and returns the relevant arguments to pass to `idSys.fit`. For example, in the following code `methodCode` is `'DPAD_CzNonLin'`. In this case, only the behavior readout parameter $C_z$ of the learned model will be nonlinear and all other parameters will be linear. You can inspect the output of `DPADModel.prepare_args` to see how the architecture of each linear/nonlinear model parameter can be specified as an argument to `idSys.fit`.\n", + "```python\n", + "methodCode = 'DPAD_CzNonLin' # Only Cz will be nonlinear\n", + "args = DPADModel.prepare_args(methodCode)\n", + "```\n", + "'CzNonLin' is translated to using an MLP for $C_z$ with default parameters (3 hidden layers, 64 units).\n", + "\n", + "Alternatively, you can provide the number of hidden layers and units as part of the string as:\n", + "```python\n", + "methodCode = 'DPAD_Cz3HL64U' # Cz would be an MLP with 3 hidden layers and 64 units\n", + "```\n", + "You can also make multiple mappings nonlinear:\n", + "```python\n", + "methodCode = 'DPAD_AKCyCz3HL64U' # This make A', K, Cy, Cz nonlinear. Each an MLP with 3 hidden layers and 64 units.\n", + "```\n", + "**Note:** When using flexible DPAD and after running `fitDPADWithFlexibleNonlinearity` function, you need to simply set the methodCode to the optimal methodCode returned by this function and follow the steps below to train DPAD (see step 1.2 above).\n", + "\n", + "After setting the methodCode manually, the rest are the same as what we explained under section 1.2 for training DPAD and running inference:\n", + "\n", + "### Train DPAD\n", + "After `args` are prepared by the `DPADModel.prepare_args` method, call `fit` to train DPAD model:\n", + "```python\n", + "args = DPADModel.prepare_args(methodCode) \n", + "idSys.fit(yTrain, zTrain, nx=nx, n1=n1, **args) # Dimensions: data x time\n", + "```\n", + "### Inference with learned model for state estimation, neural self-prediction and behavior decoding\n", + "\n", + "```python\n", + "zPred, yPred, xPred = idSys.predict(yTest) # Dimensions: time x data\n", + "```\n", + "\n", + "### We will next go through some important practical notes for running DPAD under the FAQ section." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# FAQ\n", + "\n", + "### 1. How to select state dimensions $n_x$ and $n_1$?\n", + " \n", + " The full DPAD model includes two types of states. $n_x$ corresponds to the total states learned by DPAD in stages 1 and 2 while $n_1$ refers to the behaviorally relevant states learned by stage 1.\n", + " \n", + " (1): $x_k^{(1)}$: $n_1$-dimensional state shared between the primary ($y_k$) and secondary ($z_k$) signal. When the goal is decoding secondary signal (behavior) from the primary signal (neural activity), these states are all you need. **To find the proper dimension for them, you need to set $n_x = n_1$ and sweep their values to find the smallest dimension at which behavior decoding reaches its peak performance**. This gives the low-dimensional model capturing only the behaviorally relevant states.\n", + "\n", + " (2): $x_k^{(2)}$: When interested in learning additional states to explain the residual neural dynamics not related to behavior, you can use additional $n_2 = n_x-n_1$ states. To do so, **after obtaining the optimal $n_1$ (as explained above), you need to fix the value of $n_1$ and increase $n_x$ until the neural self-prediction reaches its peak performance**. \n", + "\n", + " Example: \n", + " \n", + " 1. Tune for $n_1$: Fit DPAD with these dimensions: (n1=nx=1), (n1=nx=2), ... , (n1=nx=16).\n", + " Suppose the behavior decoding reaches its peak at (n1=nx=16). Then n1 is fixed to 16 and we will tune nx next if interested in better neural self-prediction (if not, we can use n1=nx=16 as the final dimensions). \n", + "\n", + " 2. Tune for $n_x$: Fit DPAD with these dimensions: (n1=16, nx=32), (n1=16, nx=64), ... , (n1=16, nx=128).\n", + " Suppose the neural self-prediction reaches its peak at nx=64. Then the final dimensions for the full model would be $n_1=16$ and $n_x=64$.\n", + "\n", + "\n", + "\n", + "### 2. Running DPAD across multiple sessions and cross-validated folds\n", + "\n", + "The steps explained for running DPAD and also examples provided below applying it to data are for a given dataset (session) and a given train/test split. One needs to repeat this process per analyzed sessions and cross-validated fold. For example, when analyzing 3 sessions with 5-fold cross-validation, you need to run DPAD (flexible or user-defined nonlinearity) 15 times, each time taking data from a session and training on the train split of that session, performing inference on the held-out test section. Note that for each of the 15 runs, you need to also tune state dimensions as explained under FAQ #1 above.\n", + "\n", + "### 3. What if you are interested in the best neural self-prediction?\n", + "\n", + "In this notebook we have used nx=n1=16 which only uses DPAD's stage 1 for best behavior decoding experience. In case best neural self-prediction is of interest, you need to change two things:\n", + "1) Use stage 2 in addition to stage 1 by increasing nx beyond n1, e.g., nx=64, n1=16. This allows DPAD to learn additional states dedicated to residual neural dynamics beyond the behaviorally relevant ones and therefore improves neural self-prediction.\n", + "2) In flexible nonlinearity selection, you can set the setting to select the nonlinearity that results in the best neural self-prediction instead of best behavior decoding. This is done by adding a 'y' at the end of 'GSUT' as: 'GSUT**y**_iCVF4'. The method code would be:\n", + " \n", + "```python\n", + "methodCode = \"DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\" # For optimizing neural self-prediction\n", + "```\n", + "\n", + "\n", + " ### 4. Tips for avoiding optimization issues\n", + " As in any deep learning method, having more and more training data of course helps increase the chances that the model learns an accurate and complete description of the data statistics, which also generalizes to test data. Beyond that, the following are some tips for avoiding issues that are typical for any numerical optimization:\n", + "\n", + " 4.1. **Early stopping criteria**: DPAD by default stops training when the *validation* loss does not improve for 16 consecutive epochs (each epoch is running gradient descent once over the whole data). Validation loss is calculated on the last 20% of training data that is initially set aside. However, in case the size of dataset is very small, the 20% heldout validation section for which `val_loss` is computed may become too small and thereore, stopping based on its loss may become unreliable. This can be especially the case when performing inner cross-validation with flexible DPAD. In such cases, we recommend a few things:\n", + " \n", + " **a.** Increase number of inner cross-validation folds for flexible DPAD. You can change the `number_of_inner_folds` by editing it in the methodCode for flexible DPAD: `iCVF{number_of_inner_folds}`. The default in the examples in this notebook is 4 inner folds i.e., `iCVF4`. For example, you can increase to 5 inner folds by editting it to `iCVF5`. This increases the size of the training set—and consequently, the 20% held-out portion used for calculating `val_loss`—resulting in more stable training.\n", + "\n", + " **b.** You can change the early stopping patience by adding/editing `ErSV{early_stopping_epochs}` in the `methodCode`. For example 'ErSV100' will stop training when the validation loss does not improve for 100 epochs. In general, large numbers for `early_stopping_epochs` should not hurt performance because the model from the epoch with the best loss is used after the early stopping, not the overfitted model from the last epoch. However, if validation set is too small, validation loss values will be noisy and larger `early_stopping_epochs` will make it more likely that an ovefitted model will be selected. \n", + "\n", + " **c.** Monitor training loss instead of validation loss for early stopping, by using `ErS{early_stopping_epochs}` in the `methodCode`. For example, adding `ErS3` will stop training when the *training* loss does not improve for 3 epochs (Note that 'V' is dropped compared to to 'ErSV' in default methodCode to set stopping based on training not validation). While this theoritically has the risk of overfitting, it avoids unreliablity due to scarce samples for `val_loss` calculations. We did not observe major overfitting using this criteria for reasonably large datasets (i.e., more than 10,000 training samples per fold). Note than unlike in early stopping with validation loss, here for the training loss larger values of `early_stopping_epochs` are not desired and increase the risk of overfitting. \n", + "\n", + " **d.** Check the learning curves as demonstrated in the examples in this notebook to inspect issues (e.g., is overfitting happening) and try items a-c accordingly.\n", + "\n", + "\n", + "4.2. As with any other numerical optimization solved with gradient descent, adjusting the optimizer (e.g. `AdamW`) and its parameters (learning rate, weight decay, etc.) to be suitable for the data can help reduce the chance of getting stuck in local optima. DPAD provides control of the optimizer and its parameter via the parameters of `DPADModel.fit`. Please also see `DPADModel.prepare_args` and the method `parseMethodCodeArgOptimizer` used inside it on how the optimizer settings can be specified simply by changing the `methodCode` string passed to `DPADModel.prepare_args`.\n", + " \n", + "4.3. Retrying the model fitting with different random initializations and picking the outcome with the best final training data accuracy is another way to reduce the chance of falling into local optima. DPAD allows this via the `init_attempts` argument to `DPADModel.fit`. This can also be specified by including `RTR{init_attempts}` in the `methodCode` string passed to `DPADModel.prepare_args`. We recommend at least `RTR2`.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### We will next go through a complete example of using DPAD for modeling real neural-behavioral data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Setting up DPAD\n", + "\n", + "First, we import DPAD and a few other useful tools from DPAD and other libraries." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Run these to enable python 3.11 for Google Colab\n", + "# !sudo apt-get update -y\n", + "# !sudo apt-get install python3.11 python3.11-dev python3.11-distutils libpython3.11-dev\n", + "# !sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.10 1\n", + "# !sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 2\n", + "# !sudo apt-get install pip" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install --upgrade DPAD" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "!python --version\n", + "# !sudo update-alternatives --config python3\n", + "\n", + "!pip install --upgrade DPAD # Install or update to the latest version of DPAD\n", + "\n", + "# Install dependencies only required for this notebook and other development work\n", + "!pip install sympy" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:17:26\u001b[0m \u001b[34mtensorflow\u001b[0m [module_wrapper.py > 149] \u001b[1;30mWARNING\u001b[0m \u001b[33mFrom e:\\DPAD-Notebooks\\.new_venv\\Lib\\site-packages\\keras\\src\\losses.py:2976: The name tf.losses.sparse_softmax_cross_entropy is deprecated. Please use tf.compat.v1.losses.sparse_softmax_cross_entropy instead.\n", + "\u001b[0m\n" + ] + } + ], + "source": [ + "import logging\n", + "import os\n", + "import sys\n", + "\n", + "sys.path.insert(0, os.path.join(\"..\", \"..\"))\n", + "# sys.path.insert(0, os.path.join(os.path.dirname(__file__), \"..\", \"..\"))\n", + "\n", + "# Setting up logs\n", + "logging.basicConfig(level=logging.INFO)\n", + "logger = logging.getLogger(__name__)\n", + "\n", + "import coloredlogs\n", + "\n", + "coloredlogs.install(\n", + " level=logging.INFO,\n", + " fmt=\"%(asctime)s %(name)s [%(filename)s > %(lineno)s] %(levelname)s %(message)s\",\n", + " datefmt=\"%Y-%m-%d %H:%M:%S\",\n", + " logger=logger,\n", + ")\n", + "\n", + "\n", + "# Prepare plots\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "matplotlib.rcParams[\"figure.facecolor\"] = \"w\"\n", + "matplotlib.rcParams[\"axes.facecolor\"] = \"w\"\n", + "matplotlib.rcParams.update(\n", + " {\"font.size\": 16, \"axes.titlesize\": 14, \"axes.labelsize\": 14}\n", + ")\n", + "\n", + "# Import DPAD tools\n", + "import DPAD\n", + "from DPAD.DPADModel import DPADModel\n", + "from DPAD.tools.evaluation import evalPrediction\n", + "from DPAD.tools.file_tools import pickle_load\n", + "from DPAD.tools.flexible import fitDPADWithFlexibleNonlinearity\n", + "from DPAD.tools.plot import prepAxesStyle\n", + "from DPAD.tools.plot_model_params import plot_model_params\n", + "from DPAD.tools.tools import get_one_hot\n", + "\n", + "# Just to enable loading of the sample simulated data provided here\n", + "from PSID import LSSM\n", + "from DPAD.tools import SSM\n", + "\n", + "sys.modules[\"DPAD.SSM\"] = SSM\n", + "if LSSM.__module__ != \"PSID.LSSM\":\n", + " import importlib.util\n", + " spec = importlib.util.spec_from_file_location(\"PSID\", \"LSSM.py\")\n", + " if spec is not None and spec.loader is not None:\n", + " LSSM_module = importlib.util.module_from_spec(spec)\n", + " sys.modules[\"DPAD.LSSM\"] = LSSM_module\n", + "\n", + "\n", + "# Set random seeds for exact reproducibility\n", + "seed = 42\n", + "import random\n", + "\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "\n", + "random.seed(seed)\n", + "np.random.seed(seed)\n", + "tf.random.set_seed(seed)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Example: Modeling real neural-behavioral data with DPAD" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Working with real neural data\n", + "\n", + "Let's download some neural data and use DPAD to model the data. We will use the data from the pmd-1 dataset on [CRCNS](https://crcns.org/data-sets/motor-cortex/pmd-1/about-pmd-1), which is publicly released by the Miller lab:\n", + "\n", + "> **Link:**\n", + "> https://crcns.org/data-sets/motor-cortex/pmd-1/about-pmd-1\n", + ">\n", + "> **Reference:**\n", + "> Matthew G. Perich, Patrick N. Lawlor, Konrad P. Kording, Lee E. Miller (2018); Extracellular neural recordings from macaque primary and dorsal premotor motor cortex during a sequential reaching task. CRCNS.org.\n", + "http://dx.doi.org/10.6080/K0FT8J72\n", + "\n", + "A CRCNS.org account is required to download the data from the downloading link in the above page (~385MB). Once you download the data, unzip `data_and_scripts.tar.gz` and place the raw data files under `\\data_and_scripts\\source_data\\raw`. We will work with monkey T that has 3 recording sessions: `MT_S1_raw.mat`, `MT_S2_raw.mat`, and `MT_S3_raw.mat`. The data structure is explained in `crcns_pmd-1_data_description.pdf` that can be downloaded along with the data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Below we implement a few auxilary functions that we will need to work and plot this dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from DPAD.tools.plot import prepAxesStyle\n", + "\n", + "def plotSpikeRaster(spike_times, spike_ids, title_head='', title='spike times', zoom_period=None, trial_start_time=None, trial_end_time=None):\n", + " # Plot a raster of spikes\n", + " fig = plt.figure(facecolor='w', figsize=(12,5))\n", + " ax = fig.add_subplot(1, 1, 1)\n", + " prepAxesStyle(ax)\n", + " all_spike_times = np.concatenate(spike_times)\n", + " all_spike_ids = np.concatenate(spike_ids)\n", + " if zoom_period is None and trial_start_time is not None:\n", + " zoom_period = np.array([trial_start_time[0], trial_start_time[0]+10])\n", + " if zoom_period is None:\n", + " max_time = np.max(all_spike_times)\n", + " ax.set_xlim([0, max_time])\n", + " plot_inds = np.where( np.logical_and(all_spike_times >= zoom_period[0], all_spike_times < zoom_period[-1]) )[0]\n", + " ax.scatter(all_spike_times[plot_inds], all_spike_ids[plot_inds], s=0.01, color='k')\n", + " ax.spines['top'].set_visible(False)\n", + " ax.spines['right'].set_visible(False)\n", + " ax.set_title(f'{title_head}{title}')\n", + " ax.set_xlabel(f'Time (s)')\n", + " ax.set_ylabel(f'Neuron index')\n", + " ax.set_xlim(zoom_period)\n", + " if trial_start_time is not None:\n", + " for ts, te in zip(trial_start_time, trial_end_time):\n", + " ax.axvspan(ts, te, alpha=0.25)\n", + " plt.show()\n", + "\n", + "def plotSpikeCounts(t, spike_counts, spike_counts_smooth, title_head='', title='spike counts', zoom_period=None, trial_start_time=None, trial_end_time=None):\n", + " # Plot the neural-behavioral data\n", + " if zoom_period is None and trial_start_time is not None:\n", + " zoom_period = np.array([trial_start_time[0], trial_start_time[0]+10])\n", + " if zoom_period is None:\n", + " zoom_period = [np.min(t), np.max(t)]\n", + " zoom_period_inds = np.where( np.logical_and(t >= zoom_period[0], t < zoom_period[-1]) )[0]\n", + "\n", + " # Plot a binned spikes\n", + " fig = plt.figure(facecolor='w', figsize=(12,5))\n", + " ax = fig.add_subplot(1, 1, 1)\n", + " prepAxesStyle(ax)\n", + " ax.plot(t[zoom_period_inds], spike_counts[zoom_period_inds, :]+np.arange(spike_counts.shape[-1])[np.newaxis,:], label='spike counts', alpha=0.5, linewidth=0.4)\n", + " ax.set_prop_cycle(None)\n", + " ax.plot(t[zoom_period_inds], spike_counts_smooth[zoom_period_inds, :]+np.arange(spike_counts.shape[-1])[np.newaxis,:], label='smoothed spike counts', linewidth=0.8)\n", + " ax.set_title(f'{title_head}{title}')\n", + " ax.set_xlabel(f'Time (s)')\n", + " ax.set_ylabel(f'Neuron index')\n", + " if zoom_period is not None:\n", + " ax.set_xlim(zoom_period)\n", + " if trial_start_time is not None:\n", + " for ts, te in zip(trial_start_time, trial_end_time):\n", + " ax.axvspan(ts, te, alpha=0.25)\n", + " plt.show()\n", + "\n", + "def plotBehavior(t, z, labels=None, title_head='', title='cursor kinematics', zoom_period=None, trial_start_time=None, trial_end_time=None):\n", + " if zoom_period is None and trial_start_time is not None:\n", + " zoom_period = np.array([trial_start_time[0], trial_start_time[0]+10])\n", + " if zoom_period is None:\n", + " zoom_period = [np.min(t), np.max(t)]\n", + " zoom_period_inds = np.where( np.logical_and(t >= zoom_period[0], t < zoom_period[-1]) )[0]\n", + "\n", + " # Plot the cursor time series\n", + " fig = plt.figure(facecolor='w', figsize=(12,5))\n", + " axs = fig.subplots(z.shape[-1],1)\n", + " for zi in range(z.shape[-1]):\n", + " ax = axs[zi]\n", + " prepAxesStyle(ax)\n", + " ax.plot(t[zoom_period_inds], z[zoom_period_inds, zi], label=labels[zi] if labels is not None else f'z{zi}')\n", + " if zi == 0:\n", + " ax.set_title(f'{title_head}{title}')\n", + " if zi < z.shape[-1]-1:\n", + " ax.set_xticks([])\n", + " ax.legend()\n", + " if zoom_period is not None:\n", + " ax.set_xlim(zoom_period)\n", + " if trial_start_time is not None:\n", + " for ts, te in zip(trial_start_time, trial_end_time):\n", + " ax.axvspan(ts, te, alpha=0.25)\n", + " plt.show()\n", + "\n", + "def plotCursorPosition(z, tg_times, tg_pos, labels=None, title_head='', title='cursor kinematics', t=None, zoom_period=None, trial_start_time=None, trial_end_time=None):\n", + " if zoom_period is None and trial_start_time is not None:\n", + " zoom_period = np.array([trial_start_time[0], trial_start_time[0]+10])\n", + " if zoom_period is None:\n", + " zoom_period = [np.min(t), np.max(t)]\n", + " zoom_period_inds = np.where( np.logical_and(t >= zoom_period[0], t < zoom_period[-1]) )[0]\n", + " tg_zoom_period_inds = np.where( np.logical_and(tg_times >= zoom_period[0], tg_times < zoom_period[-1]) )[0]\n", + "\n", + " # Plot the cursor time series\n", + " fig = plt.figure(facecolor='w', figsize=(5,5))\n", + " ax = fig.add_subplot(1, 1, 1)\n", + " prepAxesStyle(ax)\n", + " ax.plot(z[zoom_period_inds, 0], z[zoom_period_inds, 1])\n", + " ax.scatter(tg_pos[tg_zoom_period_inds, 0], tg_pos[tg_zoom_period_inds, 1], s=10)\n", + " ax.set_aspect('equal', 'box')\n", + " ax.set_title(f'{title_head}{title}')\n", + " if labels is not None:\n", + " ax.set_xlabel(labels[0])\n", + " ax.set_ylabel(labels[1])\n", + " ax.legend()\n", + " plt.show()\n", + "\n", + "import pickle\n", + "def pickle_load(filePath):\n", + " \"\"\"Loads a pickle file\n", + "\n", + " Args:\n", + " filePath (string): file path\n", + "\n", + " Returns:\n", + " data (Any): pickle file content\n", + " \"\"\"\n", + " with open(filePath, 'rb') as f:\n", + " return pickle.load(f)\n", + "\n", + "def pickle_save(filePath, data):\n", + " \"\"\"Saves a pickle file\n", + "\n", + " Args:\n", + " filePath (string): file path\n", + " data (Any): data to save in file\n", + " \"\"\"\n", + " with open(filePath, 'wb') as f:\n", + " pickle.dump(data, f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loading the neural and behavioral data and visualizing them\n", + "We will next load the data for each session of this dataset and collect the events and neural-behavioral data for them. As the neural data, we will compute spike counts in 50ms bins (followed by Gaussian smoothing with a 50 ms s.d.). As the behavior data, we will load the 2D position and velocity of the cursor, and down sample it to a 50 ms time-step to match the extracted spike counts." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Session 1 - Loading data from G:\\Shared drives\\workshop\\Data\\Miller_Data\\data_and_scripts\\source_data\\raw\\MT_S1_raw.mat\n", + "Session 1 - Binning spikes in 50.0ms bins (9264 total bins during trials)\n", + "Session 2 - Loading data from G:\\Shared drives\\workshop\\Data\\Miller_Data\\data_and_scripts\\source_data\\raw\\MT_S2_raw.mat\n", + "Session 2 - Binning spikes in 50.0ms bins (13357 total bins during trials)\n", + "Session 3 - Loading data from G:\\Shared drives\\workshop\\Data\\Miller_Data\\data_and_scripts\\source_data\\raw\\MT_S3_raw.mat\n", + "Session 3 - Binning spikes in 50.0ms bins (11921 total bins during trials)\n" + ] + } + ], + "source": [ + "# Let's load the data and see how it looks\n", + "import os\n", + "import matplotlib.pyplot as plt\n", + "from scipy.signal import decimate\n", + "from PSID import MatHelper as mh\n", + "\n", + "from DPAD.tools.GaussianSmoother import GaussianSmoother\n", + "\n", + "sessions = range(1, 4)\n", + "\n", + "raw_data_dir = r'G:\\Shared drives\\workshop\\Data\\Miller_Data\\data_and_scripts\\source_data\\raw' # Change this according to your download path\n", + "# raw_data_dir = os.path.join(os.path.dirname(DPAD.__file__), '..', '..', '..', 'Data', 'Miller_Data', 'data_and_scripts', 'source_data', 'raw') # Change this according to your download path\n", + "\n", + "all_session_data = []\n", + "for si, session in enumerate(sessions):\n", + " filepath = os.path.join(raw_data_dir, f'MT_S{session}_raw.mat')\n", + " print(f'Session {session} - Loading data from {filepath}')\n", + " fD = mh.loadmat(filepath)\n", + " spike_data = fD['PMd']\n", + " ny = spike_data['units'].size # Number of units in this session\n", + " spike_times = [spike_data['units'][ui]['ts'] for ui in range(ny)]\n", + " spike_ids = [ind*np.ones((len(times), 1)) for ind, times in enumerate(spike_times)]\n", + "\n", + " max_time = np.max(np.concatenate(spike_times))\n", + "\n", + " # bin spikes\n", + " bin_size = 0.05 # 50 ms\n", + " Fs = 1 / bin_size\n", + "\n", + " # Extract trial structure\n", + " events = fD['trial_table']\n", + " trial_start_time = events[:, 0]\n", + " trial_end_time = events[:, 21]\n", + " tg1_pos = np.concatenate((events[:, 4:5], events[:, 5:6]), axis=1)\n", + " tg2_pos = np.concatenate((events[:, 9:10], events[:, 10:11]), axis=1)\n", + " tg3_pos = np.concatenate((events[:, 15:16], events[:, 16:17]), axis=1)\n", + " tg4_pos = np.concatenate((events[:, 19:20], events[:, 20:21]), axis=1)\n", + " tg1_time = events[:, 1]\n", + " tg2_time = events[:, 6]\n", + " tg3_time = events[:, 11]\n", + " tg4_time = events[:, 16]\n", + " tg_pos = np.concatenate( (tg1_pos, tg2_pos, tg3_pos, tg4_pos), axis=0 )\n", + " tg_times = np.concatenate( (tg1_time, tg2_time, tg3_time, tg4_time), axis=0 )\n", + " tg_times_sortind = np.argsort(tg_times)\n", + " tg_pos = tg_pos[tg_times_sortind, :]\n", + " tg_times = tg_times[tg_times_sortind]\n", + "\n", + " # Extract behavior (cursor kinematics)\n", + " z_time = fD['cont']['t']\n", + " z_pos = fD['cont']['pos']\n", + " z_vel = fD['cont']['vel']\n", + " z_orig = np.concatenate((z_pos, z_vel), axis=1)\n", + " z_labels = ['x_pos', 'y_pos', 'x_vel', 'y_vel']\n", + " z_Fs = np.round(( 1/np.median(np.diff(z_time)) ) * 1e6)/1e6\n", + "\n", + " # Downsample behavior to the final data sampling rate\n", + " ds_rate = int(z_Fs / Fs)\n", + " z = decimate(z_orig, ds_rate, axis=0, zero_phase=True)\n", + " t = z_time[np.arange(ds_rate-1, z_orig.shape[0], ds_rate)]\n", + " if t.shape[0] < z.shape[0]: # Add back any missing last time sample\n", + " t = np.concatenate( (t, t[-1]+(1+np.arange(z.shape[0]-t.shape[0]))/Fs) )\n", + "\n", + " # Only keep data during trials\n", + " in_trial_inds = []\n", + " for ts, te in zip(trial_start_time, trial_end_time):\n", + " in_trial_inds.extend(np.where(np.logical_and(t >= ts, t < te))[0])\n", + " t_keep = t[in_trial_inds]\n", + " z_keep = z[in_trial_inds, :]\n", + "\n", + " events = []\n", + " for ti in range(trial_start_time.size):\n", + " events.append({'period': [tg1_time[ti], trial_start_time[ti]], 'tgStartPos': np.array([0,0]), 'tgEndPos': tg1_pos[ti, :], 'trialInd': ti})\n", + " events.append({'period': [tg2_time[ti], tg3_time[ti]], 'tgStartPos': tg1_pos[ti, :], 'tgEndPos': tg2_pos[ti, :], 'trialInd': ti})\n", + " events.append({'period': [tg3_time[ti], tg4_time[ti]], 'tgStartPos': tg2_pos[ti, :], 'tgEndPos': tg3_pos[ti, :], 'trialInd': ti})\n", + " events.append({'period': [tg4_time[ti], trial_end_time[ti]], 'tgStartPos': tg3_pos[ti, :], 'tgEndPos': tg4_pos[ti, :], 'trialInd': ti})\n", + "\n", + " get_closest_ind = lambda array, val: np.argmin( np.abs(array-val) )\n", + " for ei, event in enumerate(events):\n", + " events[ei]['startPos'] = z_keep[get_closest_ind(t_keep, events[ei]['period'][ 0]), :2] # Actual start position of the trial\n", + " events[ei]['endPos'] = z_keep[get_closest_ind(t_keep, events[ei]['period'][-1]), :2] # Actual end position of the trial\n", + "\n", + " print(f'Session {session} - Binning spikes in {1000*bin_size}ms bins ({t_keep.size} total bins during trials)')\n", + " spike_counts = np.zeros((t_keep.size, len(spike_times)))\n", + " for time_ind in range(t_keep.size):\n", + " for unit_ind in range(len(spike_times)):\n", + " spike_counts[time_ind, unit_ind] = np.sum(np.logical_and(\n", + " spike_times[unit_ind] >= t_keep[time_ind]-bin_size,\n", + " spike_times[unit_ind] < t_keep[time_ind]\n", + " ))\n", + " # Smoothing the binned spikes with a 50ms s.d. gaussian kernel\n", + " spike_counts_smooth = GaussianSmoother(std=0.05,Fs=Fs).apply(spike_counts)\n", + " y_keep = spike_counts_smooth\n", + "\n", + " session_data = {\n", + " 'session': session,\n", + " 'spike_times': spike_times,\n", + " 'spike_ids': spike_ids,\n", + " 'spike_counts': spike_counts,\n", + " 'y': y_keep, # or spike_counts_smooth\n", + " 'z': z_keep,\n", + " 't': t_keep,\n", + " 'z_labels': z_labels,\n", + " 'trial_start_time': trial_start_time,\n", + " 'trial_end_time': trial_end_time,\n", + " 'tg_times': tg_times,\n", + " 'tg_pos': tg_pos,\n", + " 'events': events,\n", + " 'trials': fD['trial_table']\n", + " }\n", + " all_session_data.append(session_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This data is from a non-human primate performing controlling a cursor with its fingertip position. The cursor on the screen and is expected to follow targets on a grid. Let's visualize the data." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9sAAAHFCAYAAADiyuoeAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAA2IBJREFUeJzs3Qd8W+XVBvDHQ/LeO15JbGdvQkLIICEEAmXPsgkfhVI2tJQPKNCWUlaZhbZ80DIKZRYIm5CEhJAACWTvOI5H7HjvKUv6fufIcmzHdjxka/j5txfJkiJdy1e699xz3vN6Wa1WK4iIiIiIiIjIYbwd91REREREREREJBhsExERERERETkYg20iIiIiIiIiB2OwTURERERERORgDLaJiIiIiIiIHIzBNhEREREREZGDMdgmIiIiIiIicjAG20REREREREQOxmCbiIiIiIiIyMEYbBMRkct4+eWX4eXlpZdEHQ0fPlyXnnjggQd0W/r6668HfL3cAT9bRESDj8E2EZEbqq2txUMPPYRp06YhODgYfn5+SEpKwty5c/G///u/yMzMdPYqeoS6ujr85S9/wSWXXIIxY8bA29tbA5YDBw44e9WI2pFtUrbNq666ytmrQkRELXztV4iIyD1UV1djzpw52LJlC9LT03HZZZchKioKJSUl+OGHH/Dwww8jLS1NF3dzzjnn4LjjjkNCQgJcQVFREX7961/r9dTUVERERKCsrMzZq0U9cOONN+LnP/85UlJSnL0qLsHVPltEREMBg20iIjfz1FNPaaB9zTXX4IUXXtBsVltZWVlobGyEOwoLC9PFVURHR+PLL7/EMcccg8jISCxevBhffPGFs1eLevi3k4Vc87NFRDQUsIyciMjNrFu3Ti9vuOGGIwJtMWLECC157ixLe9ttt2k2XMrOJRA577zzsG3btiMeu3fvXixZskSfSx4rgebkyZNx6623wmq1tj6uoKAAt9xyCzIyMhAQEIDw8HCMHTsWv/zlL1FZWdn6OLl+3333Ydy4cVr2Hhoaqutx5ZVXIjs7u0fjSr/99lv87Gc/03Xx9/fX3/H+++/XUu+O5Dnmz5+PwsJCfQ35XWX9JLPXmzG8sq6LFi3S13QWeb//9a9/6RABeX8DAwP1/b7uuuuQk5PTo/HM8l503FbajmmW91uGJMhzy2OFxWLBiy++iBkzZujvL++fDFU444wzOn0PZR1nzpyp75kscr2zv6P8W3ldef21a9fi5JNP1t+rs225p5544gkt8V+4cKFWfnT8/Tortd63b59me6VaISgoCCeddBI2b97c6fP35rNj/zvINn/99ddrJlmef968efjpp5/0Mfn5+VqREhsbq++rvAfymevo/fffx8UXX6yvK38bCZZlO3jvvffaPU7eZ/msildeeUV/R/ti//27+2zt378f1157bevnXdZLtoOOj5XXPeGEE/R++QwOGzZM37eO60NERDbMbBMRuRkpGRd79uzBlClTevRvZAy3HDzn5eXpgf3ZZ5+tAYQcJEumdvny5Roc2QMBCbBkXLgEtxdddJFel2Dg+eefx+OPPw5fX18NcmfPnq0BjDynBC5NTU2aWX/ttde0/FqCAwkWTznlFHz//ff6eMkOS2AkQfbSpUtx+eWXa4l2d9555x0NOiQQkPWRg33JOP/hD3/Q9ZeAQg7+26qoqNBye1kHeQ35fd966y1dlx9//BETJkyAq5OAV37fd999F4mJifoeyIkKec/ffvttnHrqqf0uk37sscewcuVKnHXWWfp39PHx0dtl7P+jjz6qwxFkzHpISAgOHjyINWvW4KuvvmoNysXNN9+MZ599Vtfxf/7nf/Q22bbkhM3GjRvx9NNPH/G6EmhL34EFCxZooNf2xEFPybb129/+Vn+HCy64AP/+979hNBqP+u/k/ZMTL+PHj8fVV1+tn48PP/xQ12Xnzp2Ii4vr02fHTj4HcpKmoaFB/35y0kf+XhKYyu8t26AE4RJwS9D/0Ucf6WdNXtv+/tv/BvL7yHYsjy8uLtbPzPnnn49nnnkGN910kz5OvgfkpJe8z3JSTNbR7mgN5eTvKa8tJylkvaT0vry8vPXvZh8D/re//Q2/+tWvdD3ksy7fQ4cOHdKhK3JSQE4+EBFRB1YiInIrH374oaSWrSEhIdY77rjD+sUXX1hLSkq6/TfHH3+81cfHx/r555+3u3337t36PBMnTmy97ZlnntHnf+qpp454ntLS0tbrS5cu1cfdeuutRzyuurra2tDQoNe3bNmijzv77LOPeJw8Rh5r969//UsfK5d2lZWV1rCwMKufn5918+bNrbebzWbrRRddpI//wx/+0O555TZZfvWrX+nj7F588UW9/brrrrP2xSmnnKL/PisryzoYnn32WX29hQsXWuvq6trdJz+3/Xukpqbq0pkTTjhBn6et+++/X28LCgrSv1FHkZGR1mHDhllra2uPuK/t665atUqfZ+zYsdaKiorW28vKyqyjRo3S+1avXt16+8qVK1v/Pv/85z97/F50/B1NJpP1iiuu0Oe54YYb2v2d2/5+8np28nezv/bDDz/c7vH33nuv3v7nP/+5z58d+zrK81xwwQW6jnaPPPKI3h4eHm697bbbrBaLpfW+66+/Xu9777332j1XZmbmEe+BfF7kNeUz0fZvY//drrzyyk7fu84+W/L5S0xMtHp7e1s/++yzI/5Nbm5u6/Vp06ZZjUajtbCw8IjHHe37h4hoqGIZORGRmznzzDO1Q7bElHIp2Sgpa5VSU2kK1bEcVTJUkk2Tcmp5bFujRo3CL37xC2zduvWIklgpb+2os3Lqzh5n75B+tMfJY+Sx3ZGMo5TkSgZy0qRJrbdLdlwyr5Jl76w0Vkp3H3nkEX2cnbwH8vj169fDHUglgWQ6JavY8f2Tnx1R3i5Z5YkTJ3Z6n2RV22Za7dq+rpQt28u2244JlvJsKfMXnf19pGxdMt99IVUVkol/9dVX8fvf/x5//etf2/2dj0bKpX/zm9+0u82ekW+7bfT1syPsFSB2UpUgmpub8eCDD7Yrm7ff17GMfeTIkUc8r3xeJNssn4n+bsfy2ZJqBcmwS8VJRzJsoC2DwaBLV9U2RETUHsvIiYjc0O23364H+p9//rkGAxs2bNAy7eeeew4vvfSSlktLUC6+++47vZRSVgmIOtq1a1frpZRWy5hcKV+VMeFSIisH4TJOs+OBv4xBlZJS6X4uQcLpp5+uj5Mx220DCflZguT//Oc/WoorJa5Sliulrz0JkCTgEW3Llu2khFrWS0rqpQxWSp3bBkMdA3kJfqREWErMB9MHH3yATZs2tbtNfp/Ofie7mpoaLSuWkygyRnugyJCBzkg5sQT7sk3IdSmxnjVr1hFBf3d/H/k3ouPvLo499tg+rW99fb2OzZby5b///e86dr23Otv27IFl222jt5+dticaOpb327uAy99Sxl93dp8M4WhLytXl8/XZZ5/psAv53dvq+PjekvdQSHn80cg2cOedd+rvKcMK5G8r5e0yrIGIiDrHYJuIyE1JYCnjVGURkum6++67NUCSLJ1krCQzaZ+q6pNPPtGlKzIu2z7GU4IMCS4+/fRTHWsqpCGZjJG2v55kMeVx0vhMxpzKY0VycjLuuusuHd9pD3BXrFihzyfjXO+44w69PSYmRjPx99xzT6fZU7uqqiq9bDuOtmOgIsG2PK5tsN1VECDrYzabMdjBtj0D3FZ3wba9wZyMgx5IXb2vMl5XMsDS+EwysbLIuPgLL7xQKyrsnb7lfZfAVf6enT23nHix/w178rpHIydVJMCXbKo9mO+tzrYNexa67bbR289OT56/u/tMJlO715YTEjKWXXodyHhvaSQnnxU5eSFZ6f7OOtCbbUx6MMh7LlUW8ve3Z+5lvPeTTz7Z2qCNiIgOYxk5EZGHkOBXymml2ZjMuS3lrW0P7qWBlZSed7VIqaydZK+kKZcc8Ev3cwmopRmSNHuSruB2kr2TEmFp3CQBkJRtS1MvyYpLJttODtLl9eUEwI4dO3Q9pRRZyoylFLw79vWX7GJnZL3aPs4VyXvU8f3uLFPalr0kW96znpCAV0qUO9O2M3xHXXUBl0BKAqzt27frOrzxxhvaCVtKty+99NLWx8n7Ln9z2QY6ksys/K6d/W362n1cmuNJoClBt5ys2L17NwZKXz47jiIVKhJo//GPf9QmZrIOcl22G2nu5ggSvPd0G5O/lwzlkNJ1+VtLU7Rzzz1X/xZS1TLYJ7CIiNwBg20iIg8iB8QyVrkte6dk+5RhvSHjM+XAXsbFSvdjCSw+/vjjTgM9Kc2VMlN7kC1dkztbPykrl2B82bJlXT6uralTp+plZ9NN5ebmardoKSVvm9X2BFICL1OlSXf3zqaF6khKlyW47Rhw2zvJ94dM8STjimXYgpS1Szdye0lzd38f+2097ZrfUzJ+WrYbKfmW7PZABdz9+ez0l2zXQsamd/TNN98ccZu9OqQ3Qa99CIF09u8NOXkmw0FkuMqJJ56oJ9CkqzoREbXHYJuIyM384x//6LIxkpQryzhfyVjZx5DKAbUEDRIEy8FxR5KVXLVqVevPMi1WZ2W/9syyfYotyXh2lm3u+DiZZkmWoz2uKxJsSJZXypnlNTtO+yTBpX16Ik8jJyUkeJKS/I7jdWVaKXuZs5CSYylDfv3119u9RzL+vmOZ89FIebL0AuhInkfGkstJGPuYZ3tWV07ItN1uJJsut7V9jCPJ1FoyfEECbslw28dPO1JvPzuOZJ8OT7LabUmFgX3IRseTLXIyS05A9ZT0dZCx6jJlmkxj1lHbjLecOLE1+j9Mtjf7Nni0zzER0VDEMdtERG5GmiX98pe/1AyjjOWUrKMEQVLGLRkvCYJk3HbbbuASLEgGUJocPfXUU9oJWhpdSZmqZO2kLFSCNyFzZEtALw3QZI5lKaWVzJUc4Evpt72DtGSmpaOzrIM0I5Ns1/79+zXjKAfeEigKGV8q5aYSuEimNj4+Xg/i5cSArOttt93W7e8rr/9///d/mlmVwEdK2WV8sGRX5cSAPG/HztKOJKXUUpYv7KX5cpu9+do111yjjaIGwvXXX6/BnIybl8ZaEhzJ+yF/NwmOpNTYPqeyjH+XExKyPvK3kfdItgcJRmXu5Y6drrsjgb3973rMMcfocAEJsqWqQcr25fe3b1+ynch8z1LmLCd4ZL5lCcpkfL40xJM5uOUxA0Eapck6SVM/2b6lN4BUTjhSbz47jiRzw8uwDHlvZR50Cb7lbyhNC+Xz9N///rfd42V7lBMuq1ev1n8r24t8vrqbx17+hrJtSRNEmbNdLmVbkZMm8rmVru/2Bniyncm2J5Uu8nwSaMt2Jt8NMu93V69BRDSkOXvuMSIi6p1du3ZZH330UeuiRYusI0aMsPr7++uSlpamc+xu2LCh038n8x7LXMITJkywBgQEWIODg60ZGRnWSy65xPrf//639XHfffedzkMtj5M5geWx8rgbb7zRmp2d3fq4HTt2WG+55Rbr1KlTrVFRUToP9siRI3Udtm/f3m6u3rvuust63HHHWWNjY3Wu3pSUFOu5555rXbdu3VHnAraTuZpPPfVUXSd5DpnD+Xe/+521pqbmiMfKc8jc0p3pbj7qrh5vn5u5s6WzdXUkmY9Z5geX90/mxA4MDNS/xy9/+UtrTk5Ou8euWLHCOnPmTP1byN/k8ssv13mRu5tnu+081HZNTU06L/TJJ59sTUpK0vc7Li7OOm/ePOsbb7zRbo5oO5kz+9hjj9X1k0WudzaPtn2ebXn93urqbyfPKe+NrKN92+tunu2u5qLuarvp6Wenu3Xs7vm7Wq9Nmzbp3yAiIkLn9JZ/+9VXX3X5OZG5v0877TT9jHh5ebX7/bv7bO3bt8/6P//zP/q3NhgM+jmdP3++9dVXX219zPPPP28988wz9XeT7xvZvmbMmGH929/+ptsLEREdyUv+4+yAn4iIiIiIiMiTcMw2ERERERERkYMx2CYiIiIiIiJyMAbbRERERERERA7GYJuIiIiIiIjIwRhsExERERERETkYg20iIiIiIiIiB3PrYFtmLauqqtJLIiIiIiIiIlfhCzdWXV2NsLAwLNuYhaCQEGevDhGRQ81Ki3L2Kgw56zJLnb0KRETUDe4byZ24dWabiIiIiIiIyBW5dWabiIiIiIg6J0MtTWYrmswWNJst8Df4wM/XG15eXs5eNaIhgcE2EREREZGbslisOFhRj5yyunZLTUMzTGYLOnY28vHyQoDRB0F+Pggy+iLE3xeh/ga9DAkwtF63Xwb7+8Lo4w2Djzd8vBmkE/UGg20iIiIiIjdSVW/C5rwKbMytwJa8CtQ2mnv8b81WK2oam3UBGnv1uhJrS9AdYPBBWKAB4QEGhAUYEB5oxMiYIExMDEOgkeEFkR0/DURERERELq64uhHf7S/FDwfKkFlU0y5j7W/wRkpkIFIig/QyNSpQA2Gjr3frIhntxmYL6prMqG1sRr3JjOqGZlQ3mFDVctn2Zwno5Wd5nJ3FCn0OWSrqTcjusI7yGqPjQzA5ORzTUsKRFBE4aO8PkStisE1ERERE5ILKapvwfVapzpSwt6im3X0SUE9NjsDUlHCkxQT3qMRbxmzLEhlk7PE6mC0y7tvSslh17HdtkxmV9SZU1jehos6EkppGbM+vQkFlA3YUVOnynx9yMDYhBKdPGoYpyeHw5jhxGoIYbBMRERERuQjJKH+fVYZ1+0uwq6C6NYMtoerYhFAcNzIKx6RG9Cpg7g8J4n28bUH60RRWNWBTboUuW/MqsbOgGjsLdiMxPACnT0rA7PRoLUMnGiq8rNKm0E1VVVVxnm0i8licS3TwcZ5tInKG0ppGHX+9PqsM2/IrtVzbblRcMGaNjMKMEVGDFmA76nf6fPshLN9Z1FqKHhVkxMUzUnB8WlSfO6Jz30juhME2EZGL4gHF4GOwTUSDQUqxpSxcMsASZOeW1bW7f0R0kAakksWODvaDO6trasZXO4vw2bYCLTkX6bHBuPy4VIyK6/3xO/eN5E5YRk5ERERENICaLRbsL67FjnzbeOY9hdXaZMxOkrwZscE6BlsC7Pgwf3gK6U5+5uRhWDw+Hp9sLcCHmw5iX1EN7l+6XTP2F89IRkyI/8DNM24ywWI5/F4TteXt7Q2DwTBgc887Ndi+6qqr8Morr3T7mPr6evj7e84XDhERERF5Lmkoll9Rj/0ltdhfXIOsklocKK3V5mJtyRzWk5LCMTU5HJOSwhDib4Ank47o50xNxPzRMXhnQy6+3l2MdftLsSG7DKdOSMBZU4Y5bNows9mMkpISVFdXa7BN1B0JtkNCQhAdHQ0fn6P3JnC7zPbs2bORnp7e6X2O/oWJiIiIiByhpqEZ2/MrkVteh7zyeg2ypSN3c9tB1y2C/XwxblgoxiXYlqSIgAHLprmyiEAjrp2XhlPGx+O177K1i/nSzfn4ek8xLpyehAWjYuHdg87q3QXaubm5aGxs1OGmwcHBGk8Mxfeajl75INtLTU0NKioqNMmbnJzs0PjTJYLta665RrPcRERERESuTDpu/5hdrhnZ3Yeq2zUzazvv9fCoIIyMCcbIaLkMQlyoP6e/aiM1Kgj3nDYWP+aU4/XvcnCoqgEvfpOFL7YX4qrjh+sJib6QjLYE2ikpKQgICHD4epPnCQ4O1hMzOTk5uv3ExcV5VrBNREREROTKMotr8K9vs5BZXNvu9uSIAG34lRgeiMQIf72MCjYysO4ByTZPT43ElKRwLNtZiPd+ytNmcX/8eAfmpEfjkpkpmgnvTaZSSsclcGKgTb0h20toaKhuP7GxsQ6rhGCwTURERETUhQaTWccYf7b9EGQOHx8vL4xNCNG5rqelRCA2lL2F+svXx1vHbc9Nj8FbG3J0urA1+0q0guCC6Uk4eVy8zvd9NDI+WxbJVBL1lozblnJy2YaMRqPnBNsrV67E1q1b9UxCVFQUZsyYgdNOOw1+fu491QERERERua/NuRV4aU0Wimsa9efZaVG47LhUhPci20o9F+zvi/+ZMxLzR8e2VhG8ui4bK3cX445Fo7QUvzv2ruPs+UR9Yd9uHNm93iWC7VdfffWI2xISEvDPf/4Tixcvdso6EREREdHQJOXIr36Xjc+3HdKfo4ON+J85IzAlOcLZqzYkpMUE4w9nTcDK3UV484dc1Dc1Izyw593a2QyN+mIgthunBtuTJ0/G008/jYULF2oTA+kAt3nzZjzwwANYu3YtzjzzTHz55ZeYP39+t89TU12lX4oGoxFGZsOJyEPI9xoNLr7nRGSxWvHy2gP4amcR5NB78YR4XHBMEvwNPvyOGETy3p84OhbHpkaguKYJRh9vff+7+xvY7zva44gcsf30JDj3srrgliirdM455+DDDz/UgHzTpk2dPq6qqkobINgtueF2XH3jHYO4pkREA0fGA9LgkvGBRDTEA+11uVixp1SDvV/MScG89Chnrxb1cN8oXcjz8/MxfPhw+PtzLD31TkNDAw4cOIBhw4b1aDhzT5rwuUQZeWdnCX7/+99rsC2ZbpkrT+Y868r7qzcjKDhEM9vevhxDQ0SegQcKg4/7EKKhHWj/a00WVrYE2tedMBLzMmKcvVrUy32jxBH2hag37NuNBNqOOgZzyWBbjB07tvV6Xl5et8F2cEgogkJCBmnNiIgGBw8UBh/fc6KhG2i/tOaANuKSr4HrT0jDXAbabvc9bb+PwTb1xUBsPy4bbJeWlrZrw05ERERENBBkfmdpxiXH17+an65zPBMR9Zc3XNSbb76plzK5+OjRo529OkRERETkgTZkl+G/Px3U69fNG8lAm4jcP9iWpmdLly5Fc3Nzu9tlXrOXXnoJd999t/588803w2Doeat/IiIiIqKeKKiox/MrM/X64vHxOGFUrLNXiWjA3XTTTVomPXfu3CNiMXHPPffo/dOmTdOmYb0lDerk3x84cADvv/8+5syZowlUqVaWWaY+/fTTLv9tXV0dHn74YX1teXxgYCDGjx+Pe++9F+XlnTcx/fHHH3HRRRchKSkJRqNRX2vkyJE477zztAeYMzmtjFzefOk4HhERoW9mXFwcKioqsG3bNuTk5OhjLr74Ytx///3OWkUiIiIi8lANJjP+smwP6k1mjIkPwaXHpTh7lYgGxV/+8hd89913WLNmjQaxEtzaff755/jzn/+sAevbb7/dr0ZhzzzzDJ588klMnz4dp59+OjIzM7Fq1Spd5D4J+tsqKyvTKaElKSuvf+KJJ2rSVR7/pz/9CW+88QZWrFihwbzd8uXLceqpp8JkMuksVrNmzYLZbMbBgwfxySef6PWzzjoLQy7Yljfj1ltvxYYNG7Br1y58++23OuWXBN3nn38+lixZgtNOO81Zq0dEREREHkqOOf++KhMHK+oRHmjALQsz4OvtsqMryYF/dzm54o4CDD4Oa9ol2V8JpCXh+eijj+KEE07QgFWaUl9++eX6Pr344otIT0/v1+s89dRT+Pe//41LL7209ba33npLE6q33347FixYgAkTJrTe96tf/UoD7ZkzZ2qgHBVlm3avpqYGF154IT777DN9Lokb7SQIl0C74+uIyspK7Ny5E87kkvNs95R9nu1lG7PYjZyIPM6sNM7tOtjWZR5uzklEnuvjLfl4/fsc+Hh74b7Tx2FUHI8jPWHfKCXPWVlZGDFiRKcZ2bqmZoy77wu4ox1/OAWBRsfmSaXE+uyzz9agdv369RpoSyB744034tlnn+3z80rmOTs7W59bysg7ksTqe++9h1/84hd44YUX9DapbJa/m4SmEnBPmjSp3b+RTLUE//I3lnU8/vjj9XYpMd+xY4dmxaViuj+Otv30BU/hEREREdGQsaewGv/5wTZk8cpZqQy0aciS8mrJMMssUFOnTtUgVkq+pczcEa688spub//6669bb1u9erX27pL16Bhoi8TERJxyyil6feXKla23z5gxQy8lqy1l8Z2NQXcml536i4iIiIjIkSSz+dcV+2CxArPTonDS2DhnrxINcim2ZIjddd0HwiOPPKLjtCU7HBQUpOXlUmbuCCNGjOj2dilbb5u57u7fiLS0tHaPFTK+fMuWLVpiLktAQICWx0sjNgnAx44dC2disE1EREREHk/Hoa7JQnFNI2JD/HD1nBEOGwNL7kH+3o4uxXZ333//Pfbs2aPXa2trsXXr1m4DXkeyOmA0c3x8vPYAkyZqX331lWbn5XeSy4ceekiD8d/+9rdwFpaRExEREZHHW723WPsyeHsBNy5IZ9BFQ15JSQl+/vOfa+m1NKeWkxFXXXWVjrd2hKysrC5npRIyVVfbMnGxf//+Lp/Pfp/9sXay3pLJfvDBB7XEXMZv/+1vf9PbZTpp6YLuLAy2iYiIiMjj59P+17e2A/wLpicjg+O0aYiTrLI0RJNS7iuuuAL//Oc/cccdd+hc1jJntXT47q/XXnut09tfffVVvZQA2W7evHnw9vbW5mibN28+4t8UFBRoubuQLubdkeZmv/zlL3Xst4wDlzJzZ2GwTUREREQey2S24NmV+9DYbMG4hFCcOWmYs1eJyOmkvFqC13HjxuH5559vvU3mqZYy7DvvvLPfr/H+++/jzTffbHfbu+++q53IfX19282znZKSggsuuEBPAlx33XXatM1OytuvvfZa7RYuXcjtncjF448/rp3MO5Kppffu3avXU1NT4SysnyEiIiIij/XW+lxkldQi2M8XNyxIh7fUkRMNYdL5+7777kNgYCDeeecdbYwmJACW4Fg6gssc2ZJ5lo7lfXXLLbfonNpPPPEEMjIytJxbAnl7kNyx6/hzzz2nQbI8RpqhSQZb1knGYxcXF+tY8tdff73dv5HS8d/85jcYM2aMNkOTBmn5+fmtncklay8N05yFmW0iIiIi8kibcivwydYCvX7dvJGIDHJMl2UidyVBqwTAZrNZg1vJbLclGeaXX35ZxzvLOG77+Oq+Bttvv/22BsxLly7Ftm3bMHfuXHz00Ue47bbbjni8zPe9du1azbBLYP3ll1/i448/RnR0tI69/vHHH3UO77bkd5D1tAflkjWXseKLFi3SzLr8Ls7kZXVEG7h+kjMq8kZJfX5TU5NOWC6t2uWPYDAYuvx3VVVVCAsLw7KNWQgKGbpjb+RPWF5nQlltI8pq7ZdNqG0y630yvYWl5dL2sxXyV5dFrksjTvlAyXle+3U5C9PxNtt1L20sYmveab/e4d+2nDD2ltvlNvlfy79pvd7mfn+DD8IDDYgINCI8wIDwQCOMvjwPRDQrLcrZqzDkSPMkIvIMFXVN+O1/t6Kq3oSTx8VhyezB6bBMzts3SpmxBFoSqMm4XXIOCYilyVpWVtYRwbErG4jtx+ll5LfeeiuefvppPRtx4oknIjg4GCtWrNAW7XLWQ85oSDkAHVbfZEZmcQ32FtVgny7VqGpwrQnc+2tYmL82L8mIDdbLpPAAln0RERFRj0gy4fmvMzXQTo4MxKUznTdmk4iGLqcG2x988IEG2hJgS9rfXk8vbegl8JZa+9/97nda0z/UldY0YkN2uS4786tg7lCQ4OPlhYggW3ZYSqQigow6NsmnJXvs3ebStrRkpL1sGW7Alu22tFy3ZcH11pYsuBUW2122zHhLRt12ac+Y29alNXNuf0zLv7Hdd3hOPXvGXU4elNc1oaLOhIr6JpjMVuRXNuiyak+xPjbIzwfHjYjC3IwYjIoL5ryYRERE1KVPthRg68FKGH28cfOJ6ayYI6KhF2zLROPirrvuajdwXerypSue1PT/9a9/1YBbysWHmsKqBi1p/OFAmTb2aCs62IiM2BCkS+Y3NhipUUEesSORQFyy9JlFkrmvxp7CGs3i1zaasXxXkS5xoX6Ykx6NE0bFICaEJUJERER0mBw3SFM0ccXxqUiKCHT2KhG5JUmA/vrXv+7x46+55hrMmTNnQNfJ3Tgt2D548CDWr1+v1y+55JIj7pc/VHJyMnJzc/Hpp5/qQP6hksH+bn8Z1u0vQWbx4QBb8rij4kJwTGoEpqdGICHcM0vrJWMdFmDAtNQIXYTZYsXOgip8s7cY32eVobCqEe/9dBDvbzyI2enROGtKIhI99P0gIiKinqtrasYzy/dqBeDMEZE4cXSss1eJyG3V1NTglVde6fHjpXu5xHD9aarmaZwWbG/cuFEvIyMjdRB6Z6ZPn67BtjzWU4Nti8WK/SU12JhbgU05FdjfJoMtldIThoXhuJFRGmRLEDoU+Xh7YUJimC5LZpu1lP7r3UXYni8BeAnW7C3BjBGROGdqomb4iYiIaOiR6rh/rslCUXWjVgD+Yu5IDjsj6gdpbuYCvbTdmtOCben0Zm8v3xXJbLd9rLuTDK2UhueV1yOvvA655XUaMFZ3aG42Oi4Ex6dFaQApnbnpMOlcLiXkskiZ2AcbD2rwLRlvWaalhOPsKYnaVI2IiIiGDjkB/21mqfaluenEDAT5Ob0PMBENcU77FqqurtZL+yTqnZHGafYpvrpTU12lZ10MRiOMfn4OWT95vnqTWQPhRpMFDc1mNDZb0CiXJku76w3NFjSbLRpMN1usLZcWbfwl02/V6dKsDcDk/o4CjT6YmBiGKcnhmJwU1i7A5tmkro2MDsLti0Yhp6wOH27Kx3f7S/FTToUu44eF4pwpiRibEMKz2uS2+PkffHzPidxTQWU9/vmtLTlz3rQk7WfDz7Nn6u7var/P1qCXf3/qnd5uPz2JMTzilN858ybr5ZIbbsfVN95x1MfLm1dZ34ySmiYU1zShpLap5XojKuqaUd3YrEF2Z4Fxfxl9vJAY7q9jjJPC/ZEeE4T02CD4tpnWytLc5PDX9WRJob64YV4Kzp0ci4+2FuLbzDKtGJAlIzYIZ0+Kw6TEUAbd5HZkvkcaXPz+JXI/JrMFz67Yq4mQsfHBOGN8ND/LQ3Tf2NjY2BooMdim3rJvN7Id9URPpqd2WrAdEmIr862tbd9lu+OgfBEaGtrtcz3/8Q8IDAqBwWhAQY1Zy4fqTRaU1zahot6EiromlNeZUFLTiOLqRr2U6aV6QqaMCDD6wM/X27YY2lz3bblu8NbHydhi++Lr7a0Z68OLL0IDfBEd7KdTb5HjJUYZ8cv5oTjvmEZ8vCUfX+8pxt6iWjz21X4MjwrU8vLpwyP4/pPb8Pdnt/3B5u3LoTtE7uadDdk4UFqvU57esCADvkZ+jofyvtE2ta1tIeoN+3bj5+fnsGMwX2cOuBfSAK0r9vvsj+3Kn786AG+/3k3rIB8/mY86JsQPMcF+iG65lPmpQ/0lMDYgxN9XA2pyL7Gh/rh6zkicMy1J59n8amchDpTW4anle7Wi4IzJwzBrZJRHTJVGno0HCoOP7zmRe9mUW45Ptx3S69edMBJRwY4ZTkju+T3d9j5+n1NfOfJkjdOC7alTp+plaWmpNkDrrCP5hg0b9LLtHNydCfb3gbfR9qtYYZX/aCAlY58jAg2ICDQiPNCgX8ASUEuAHRVkhK8Pgy1PJn/3y45LxZlThuHzbYd0OVhRj7+vysTr32djwehYnDQ2TrcHIiIici+HKhvw3MpMvX7K+HhMT4109iqRk/n62uIBKQPuSYkvUVv28nH7duQIXlYnDmiYMWOGzrX94IMP4p577ml335o1azB37lxN4xcWFiIsLOyIfy+N0+T2ZRuzENRSlk7UFWlSt2xHoS6ltbaxXHLSalpKBOZmRGuDOlYykCuZlRbl7FUYctZlljp7FYioB6oaTLj/w+04VNWAEdFBeOCM8axYGyKOtm/MyclBc3MzUlNT4ePD4zrqGbPZjOzsbA20u5sty62C7Q8++ADnnHOOdh1ftWpVawZbst0LFizA1q1bcccdd+Dxxx/v9N8z2Ka+kG7xP+WU48vth7At/3Cnexl/LwH3zBGRmJoSodOMETkTg+3Bx2CbyPU1NVvw0Kc7sbuwWufT/uNZEzhV6hBytH1jXV2dDkWVQFviBMlwy3WWlVNHEgZLkF1fX4/KykpYLBadetqRVRFODbbFLbfcgmeeeQYGgwELFy7UqcCWL1+OiooKzJ49G8uWLevyF2awTf11sLweX+8pwvf7y7QbvZ2PlxdGxARhTHwIRseHYExcKIL9PaJ5P7kRBtuDj8E2kWuzWK3aefy7/WXagPb3Z45HUkTv+vaQ5+8bm5qaUFRUpIG3BFNE3ZGTMYGBgYiNjYXRwQ0WnR5si7fffhvPPfccNm3aBJPJhLS0NFx22WW47bbbuv2FGWyTo8jHQJqoyVzdP2SVaVlaRzLePz7MHwktS1yovzbSk+6n0kwvwMCzpuRYDLYHH4NtItf2nx9ysHRzvs78ctfiMZiQeOQwQ/Jsvdk3yvGdxBaSsSTqjLe3tyZ9B+oY3iWC7b5isE0DQT4SMkWclKftOiRLFfIrjj7fsUw5J1O8yZgxg4+XTgdn8PFu+dl+6aXXZWo4nSLOR6aJ82qdYk4CdjlTL9ejgvwQG+rHceRDGIPtwcdgm8h1980SZL+53jZTzfUnpGHeqBhnrxY5AfeN5E5YF0vUgZzZkunDZJmbEdPaiCW/oh4FlQ3a/VSWwuoGVDc0o6ahGU1mCyxWoKaxGThcje4QMkVdXKgfhoUFICMuGGPiQxEb4scsOhERDQmNzWa8sHo/1racDDv/mCQG2kTkFhhsE/VAqL8BofEGDXS7atYigbZ0PDeZrTCZLXqbBOGmlkvbdateSpO2ZkvLpdmKxmYLGkxm1MvSZEZtU7Nm1+uazCirbdJlZ0E1lu8q0teTqexkPPmkxHDMHBmpGXUiIiJPU1TVgCeW7UF2WZ32U7l8VipOHhfn7NUiIuoRHqETOYCUiEf6GjUL7ciSOQngC6sacKiqETmltVranllci4o6kzaHkeWVdQcwY0Qk5o+KwZiEUHgz401ERB5g28FKPL18r+4LQ/19cetJozA2ofOT3kRErojBNpGLkjLxEH+DLumxIUB6tN4uGfN9xTXYWVCl40sPVtTjm70lukh5+c8mJeDEMbE6LpyIiLo/qVla24Ts0jpUN5g0qNOloRnNFqtOCSnTQLZeGrzh73v40t/grX01Dl/6QL56pWrJVsFkq16y/9y2qqntY+RSKqKkykm+422XZjS2VEnZb5fHyL5BeoTIiVVZAgzeCAs0IizAgHBZAg2ICfFz64qnvYXVOj57Q3a5/jwyOgi3LxqFqGA/Z68aEVGvsEEakRuTj+++ohqs2lOsY9mkDF0MC/fHpTNSMTUlnGO73RibwAw+NkjzbBLUZhbXYPehav3u3FNUrZVCnkhmypATsNJoMzbENoOG/Cw9QCKD/LRJp6vtzzblVmiQLc1J7RaMjsVVxw/XCjIiwX0juRMG20QeQhrISND93o95qGpo1tsmDAvFZcelIjUqyNmrR33AA4rBx2Db81TVm7A5rwIbcyuwJa8CtY3t59yVccBJkQGICDRqgKqLv6/OFCEZ5UaTGQ2dXEqfjUaTBQ2SgTbZ+nJ0Rs53ynNJcKuzUNhno2hzmywyU4Vk0GWRwFIy5ca2P8tMFj7ekKM2mWvatkB7hVTWmVBRb1vKa5tszTq7Ib9zdIixJQi3BeMSiEvmWIZDSYbce4CCcZ2KyWwbJnWgtBb7i2uRVVKL/SU1rSc+5P2Ykx6NMyYNQ2JEwICsB7kv7hvJnTDYJvIwcuD14aZ8fLq1QMsT5XDpjMnDcMExSXqgRu6DBxSDj8G2e5NDmpKaJuwprG5dpES87YFOkJ8PxiWEIiM2BBmxwRgRE+SQKRYtFluzS8mey7SO9iDaGX00pNFmUXUDiqobUVTVqLNnSKMx+Vmab8q+4WjBeESQlKQbEWiwTUdpm5bSdhJC2A8f5b/aEFRORLQ0BbWXvcsJCDkR3LYUXpauXl1OLCwcG4fTJsSzZJy6xH0juRMG20QeSg6s/rM+R5uoieFRgbhhQTqSIgKdvWrUQzygGHwMtt2DZJWleaQEkoeqGvS6LNLDoryTsvDUqEBMTY7QoTVpMcEuV0I9mOSkQHldEwo1ELcF4PLeSRAu49flvsE4MpS/wLDwAB2PLSc8RkQHYXhUkI57J+oO943kThhsE3m477NK8eI3WVqyZ/DxwiUzUnDy+Hh2LXcDPKAYfAy2XUttS6mxlBnnldfjUGWDZmm7G2ctWdnh0YHIiAvBaFniQ7REnHpGMvMVdbYpJ6UsXbLkMg2lVE1JXxC5X+gepKVZm9HHG4Y2Je/ys70MvrUU3qfN9ZYy+aF80oP6jvtGcidOa1V5tKZNF110Ed58881BWx8iTzVzRBRGxYXgH6sysTmvEq+sy9axizfMT0dogMHZq0dE1G589cbccmzOrdQxvIVVjV0+VsZWy3hjafwVL82/Wi4l0HZEWfhQJQGwlHCzjJuIqP+cPi/ElVde2entM2fOHPR1IfJUktX57eIxWLajEK9/n4MteZX43/e34taFGZr9ISJylvyKevyYXa6LjLHuWG4XE+ynJcZSCh4fZuuqLYsE20RERK7MaWXk9sx2f16eZeREvZdbVocnv9qDgsoGzWBcflwqTh4XxynCXBBL5QYfy8gHZ8ywTLllD7Dlu6gt6S9xTGoERseH6vUQf1bgENFh3DeSO+FpYaIhJjkyEA+ePQEvrN6P77PK8PLaA5pN+sXckWxMQ0QDQppubTtYqVU1Mg1Xdcv0hEJO+o0fFqoB9jEpESxfJiIij8Fgm2gICjT64paFGfhs2yG8/n021maW4kBJLW5emME5uYmo36TB1t7CGuwurMbWg5XIKatrd79MvyXdwSXAnpQUpt9JREREnsbpe7cnnngC+/bt0xLWlJQULFq0CNOmTXP2ahF5PPnMnTYxASNjgvDM8r3Ir2zA7z7chstmpmIRy8qJqAdkDmWdx7mqQafgkq7hEmQX17RvbCbfJsOjgzA5KQwTk8IxKi4Yvt7eTltvIiKiITFmuzOLFy/Gyy+/jLi4uG6fg2O2iRyjqsGk3cp/yqnQn48dHoFr56WxAZGTcVza4BuKY7blMMBktuq0TjLNk1zKPNatly23Sel3Zb1JO4bLd4ZMDdXZnNZC9vBJkYHIiA3WEvEJw8I4+wEROQT3jeROnBZsX3rppbjwwgsxZcoUDapzc3Px5Zdf4v7770dpaSkmTpyIH374Af7+/kcNtt9fvRlBwSEwGI0w+nGsF1FfyFfB59sL8cYPOTqPalSQEVcdPxzTUsKZ5XYSHlB4drAtnzkJYmsam1HT0Gy7bDTr3NI1bZeGZjSZLRrAent72S69vGDw8YLR10fnLZbF4OMt0x7r59X+iZXPsj1wPhxEW/RSFpk/WS5bpk7uk0CjT8vUW35IirAF2GkxQSwNJ6IBwX0juYqeHB/3Oti+8847sXTp0l6vzIsvvog5c+Yc9XFZWVmYOnUqKisr8eSTT+LWW289arBtt+SG23H1jXf0et2I6LCskjr8ddUBFFbbykAnJYbg8hlJSAjr+sQXDQwZz0qO12yxaEa2tKYJpbUmlNY2aZa2pKYJe4pq0GiyaJDabLEevrTartsXi9XaGtRqgCv/8zp83btl/ytBcdvb5bVtAbUZtU3N/QpyB4K/rzf8DbL4IMDgjQCDj16X20L8fBEW4ItQfwNCA2zX40L8WAFDRIOK+0ZyFQEBAUd9TK/3kPn5+di9e3evV6ampqZHjxsxYgSWLFmCp556Ch999FG3wbZd28y2t6+x1+tGRIelxRvx53Mn4oNN+fhkawG2HKzGXR/uws8mxuPsKYnsWD6IuqvsofYaTWYUS/Bc04gSXSSQbkRJtQTRjRpQ22+XztjOqenqnNHHG8F+Pgjy80WIv69eBrcsepufL4y+3rrOFlhtl1Yrms1WNDZb0NRsbrmUe20Zc9ulrdO3BMwBRlvAbA+eWy+N9uu2AFtODhARuTLuG8mdOK2MvDsvvPACrrvuOowaNarbwJ5jtokGVkFFPV79Lhubcm1jueXgf/7oGCwaG4fYUO7sBtpQLpWTXVN1YzNKqlsC5erDQbQGzy2X9uvy2N6QmDIy0IjoYD9EhxgRFeSn1yXbHGjw0SDVvkgjL982P8si5dwSzdoz0xL8yt5Uwly9rU1gbFtsAbCPlxeC/A8H08EtgTQREfXMUN43kvtxydovGbMtQhhAEzlVQngA7jxltDZOe+27AyisasTHWwrwyZYCTE4Ox8nj4jAxMQy+PgwW6Oik/Fqyym0DZXvw3BpUt1wvqW3STG1vM8RRwS0BdLBR52u2X7dd+rXeHxlk1KC5o6HYII2IiIiGSLBtsVjw9ttv6/UZM2Y4e3WIhjwZlyrjo6Ymh+On3HIs216ILQcrNdstizRpGhkdrFP5jIoL0Xm6ZQ5df18fW/avi87H1rZZP1g18JFgic3Y3G/qJx373EkAbSvpPly+XVbb2OsxykFGH0SHtATKQcbW650F0KH+vtx+iIiIaGgH26+//jqmT5+O0aNHt7u9qKgIt9xyCzZt2gSDwYCbbrrJGatHRJ2QwHl6aqQuBZX1+GpHIb7ZV6LTAe0urNYFKGj3b6RDsn2Mt8lsaVm6jrYkcG8tr/X3RXigETEdAquYED+njhuXTtESPMo8wjIeWAJI+ZXaNsSSrtDDwv2RGB6AYeEB+rO7kJMhtU0SQNsC5+LqjmOfD1+Xpaqhd+XbIiLQcESg3FnwLIuMKSYiIiJyR04Jtt955x1cdtllyMjIwLhx4xAUFIScnBwNsqWRWmBgoM6zPXbsWGesHhEdRUJYAC6fNRyXHZeKQ5UN2FNUjT2FNdhTWI2Cigbt3CykaZMsPSWBuHSJ7mruXjsJxu3BWUSQUaceknG2AUZfvS4Bml4a5NLX1hzK17vbcnd7kFlR14SKOpPOJ2zrUN0SdEqGtrpRp0/qDUm0yrRIw6ODMHFYGCYkhukJg8FksVj197GfJOg43tn++9kD7AZT78q3ZTyzPUC2lW7bTpK0DZqjWm6T8m0OOyAiIqKhwCnB9pVXXqnjsSW4/vbbb1FRUaGt09PT07Fw4ULccMMN2pWciFyblOzKuG5ZThgV265M3D63r1wKKRE3tMwFLBlse9dj+6VMiWSbX9g273B1gz3YbTOOt6ZRA2L7/MMHSut6tb7SnEqaUUnGXTL1OqVTS7bdZLH0uEO1dIzWLHtLECm/U2uDLKtV5y7Or6xHXnm9Xi+obNDFPh5Ygm8JumUOc7nsS+ZbqgTk/SlueV86BtCaeW8JoOVx8rv2hpyokMZhtvJtqSgwtivlbnubTAXV2ZABIiIioqHMJbuR9xS7kRMNPXVNUsZ9uDu1ZGwloJXbJbi3XTejXi4l4G9q7rZ0vbMxwlK+HhZgsJU7t44RPhxc97SMXb5eK+pNyC2r0zL7bQcrsa+opt24ZQlqp6VGYObwSIxNCNXfQ36nygaTvqa9cVhxhyZikn3vLfmd7I3DYjppItZ6e4hUC7hcS49BwQZpRESujd3IyZ0w2CYij9dstpWz2xazdrmWztiSUZYSaF8fmc7Je1CmYZJgekdBFTbnVmJDdlmfgmY7aSonZdntxzx33oVbHscppo6OwTYRkWtjsE3uZGimLohoSJExwrIEDe5Q6U5JxtjeaG7J7OHYW1iDH7JK8cOBMs3YS4m9ZKBlGR4V1L5hmGTZ23TkDg9g+TYRERGRq2KwTUTkJDJefXR8iC7SbE4y7zKe3D59Fc/eExEREbkvBttERC5AAmxnTmlGRERERI7l1sG2fbh5bY3M70tE5FmqqgzOXoUhp7aa+xMiIlfGfSO5Eplhy16R6HEN0vLy8pCcnOzs1SAiIiIiIqIhprKyEqGhoZ4ZbFssFuTn5x/1jAIRERERERGRI3l0ZpuIiIiIiIjIFXHSVSIiIiIiIiIHY7BNRERERERE5GAMtomIiIiIiIgcjME2ERERERERkYMx2CYiIiIiIiJyMAbbRERERERERA7GYJuIiIiIiIjIwRhsExERERERETkYg20iIiIiIiIiB2OwTURERERERORgDLaJiIiIiIiIHIzBNhEREREREZGDMdgmIiIiIiIicjC3DratViuqqqr0koiIiIiIiMhV+MKNVVdXIywsDMs2ZiEoJMTZq0NE5FCz0qKcvQpDzrrMUmevAhERdYP7RnInbp3ZJiIiIiIiInJFbp3ZJhooZosVRdUNyK9oQEFlPQoqG+AFIDTAgFB/X4T4GxAeaEBieADCA42Dtl41Dc3ILa9DblmdXlY3NOvtXl4tZ8+8vBAb4o/UqEBd4kL99TYiIiIiIhpcDLaJWtQ2NuP7rDKs2VeMPYU1GnD3RFiAAamRgUiJCkRSRCBiQ/x0iQg0wtu7b4FuU7MFByvqW4PqHLksq0N5nalXz+Pn661Bd0ZsCDLigjEqLkTXi4iIiIiIBhaDbRrSJKD+Kacca/aV4KfscjS3CbCNPt5ICPfHsPAAJIT5a2a7qqEZVfUmzSiX1TahsKoBlfUmbDlYqUtbPt5eiA42IsjoC4OPN4y+3npp8PFqzUTbNZosqG48/Nz1JnOX6yzPmRwRiOTIwA6Bs1XXX7LxOWW1GqA3Nlv0xIEs2Gp7VEywH0bGBCGl5QSBnCiIDvaDFzPgREREREQOw2CbhiTpYL8xtwJvfJ+jGWS75IgAzMmIwYzhkYgN9TtqCXaDyYy88jpkl9Yhu6wOBRX1KK5pREl1kwbyhVWNEkr3aR2D/Hw0qJagWAJruUyKCECgsWcfW3n9Q5UN2F9iC7b3FlYjp7xO108WyeLbBRh8EBlk1NJ4ydSHBxi0VN7Xxwu+3rYTBPbrrZfeXi23267bL+U2n5bHGVouTWYL6pvMqGsy64mEuiY5sdCMqgaTnqyQRUrk5X65r1Ye12SGFVY9aaHP1/LccoJBTg7ISYco+2WQXPohwOjTp/eaiIiIiMjRGGzTkLO/uAavf5+DHQVV+nOwny/mj47BnPRopEYF9eq5/A0+SI8N0aUti8WKsromFFc3anBparagyWxbms1HlqdLxts+Ftx+KcF2f7LNEqQmRgToMjcjRm+TQDazuBYHSmq1LF2y33KyQdZRLtueeHAthzP9thMY1Z0+KsjoowH4iOggjB8WinEJofozEREREdFgY7BNQ4Zkof/5bRa+2VuiP0uW9JTx8Th7SiKC/Bz7UZCx2rbsq2sFepIVn5gYpotds8WiAWx5bZNmmCvqTKiob9JMs5Sly/1ygkCvmy0wmTvcZrHfZoW5zf0dh7z7eHlp5jnQ6KOXYXJiQRrOBRgQ5u+L4JYTDEFG39bHSWWBPm/L0ths1vL9kpomlEoFgf2ythG1jWbNiNe2nERYtadYX1eGAExIDMPPJiZowzgiIiIiosHAYJuGBAnIHvtyt5Z7C8liXzg9GTEhrhUMO4OUhEtXdVkcSbL7EihLCfnhseoDNy5cys5LaxtRVNWI3YXV2J5fif0ltdpJXpavdxfhzMnDcObkRB0/T0REREQ0kBhsk8fLKqnFY1/s0k7ekkW9/aRRGB3fvuybHE+y+0ZZBimwlWx4ktHWEX5aakRrh/mdh6rwxbZD2JZfhfd+OqiVDVfMGo5jWh5DRERERORxwfZVV12FV155pdvH1NfXw9+fpZ/UNz9ml+PZFXu1K7dkbn+7eDRiQrg9DRUyPGB6aiSOSYnQhnCvfZeNoupGPP7lbkxPjcD189N63HCOiIiI3K8hrslkgsVicfaqkIvylkbABsOAVV+6xFHm7NmzkZ6e3ul9Pj7sLkx9s2xHIf61NgtWK3TM7q0LMxw+Npvcg3yBHjcyClOSw/H+xoP4ZGsBNmSX4w8f7cCdi8doJ3YiIiLyDE1NTSgqKkJdXR3M5q6nUyWyx5uBgYGIjY2F0ejYY0KXiDyuueYazXITOcq3+0q0GZo4cUwslswermOTaWiT7vEXz0jBzBGReOSL3Tpd2/1Lt+GuU8c6fMw6ERERDT4JsHNzczWAioiIQEBAgF4fyL4x5L6VD2azWSupKysrceDAASQlJWng7VHBNpEjbT1Yib+tytTri8fH44pZqfyCpXZGxgTjD2eOx8Of7cKhqgY8sHQ7fn3yaI7lJyIicnMlJSVaFpyamsoKWeqR4OBgREZGIjs7W7eflJQUOApTfeRxzdCeWLZbp4k6bmQkLmegTV2QacB+f+Z4pMcGo6axGX/6dAfWHyhz9moRERFRHzU3N6O2tlYDJwba1Buyvch2I9uPbEceldleuXIltm7diurqakRFRWHGjBk47bTT4OfHaZmo5wqrGvDw57vQYLJgXEIofjU/XedpJuqKdKe/92dj8czyvfgppwJPfbUHvzwhDXMzYpy9akRERNRL9iCJMQT1hX27ke3I19fXc4LtV1999YjbEhIS8M9//hOLFy8+6r+vqa7SmnuD0QgjP1xDUlW9CX/+bKdepkYG4vZFGfD19tLtgqg7Rh9v3HbSKPzfN/uxem8Jnv86U+fsXjQuztmrxu3XCfieExG57/d02/v4fU59JdtOT7afnlTPOjXYnjx5Mp5++mksXLhQa+NlcPrmzZvxwAMPYO3atTjzzDPx5ZdfYv78+d0+zznzJuvlkhtux9U33jFIa0+uotlixVNf7UNhVSNigo349Ukj4e9tgaW5ydmrRm5CviqvOT4Jfj7Asl0l+NfaA6hvbMLpE50bcDc0NDj19Ycifm8QEbm27vaNjY2NrYESg23qLft2I9tRT0jzvaPxsrrgliirdM455+DDDz/UgHzTpk2dPq6qqgphYWF4f/VmBAWHMLM9RL26Lhufbz+EAIM3/nDmBCRGsKs09f275+0Nefhwc77+fPaUYbjgmCSnjfuflRbllNcdytZlljp7FYiIqI/7RgnEpaP08OHD4e/vP6jrRe6voZfbj8tntrtb8d///vcabEumW9r3Jycnd/n44JBQBIWwi/BQ9M3eYg20xfXz05EU6bhW/TT0yHfPz2ekIMDogzfX5+KDTflaMfGLuSP1NmesDw0uvudERO77PW2/Ty75fU69NRDbj8t2Ix87dmzr9by8PKeuC7lu53EZZyvOnZqIY4dHOnuVyEOcNSURV88eAR8vL6zbX4p7PtiK7NJaZ68WEREREbkRlw22S0sPl/KFMGtNHVQ1mHSKL5PZiinJ4TjvmCRnrxJ5GGmQdt8Z4xAZZERBZQN+9+E2rNxdxDFgREREROTewfabb76pl6GhoRg9erSzV4dciMyh/ezyvSipaUJ8qD9uXMApvmhgjIoLwZ/PnYjJSWF6YueF1fvx7Mp9KK5m4zIiIiIictFgW5qeLV269IhJwy0WC1566SXcfffd+vPNN98Mg8HgpLUkV/Tm+hxsy6+Cn683bl80CkF+Ltl6gDxEqL8Bdy4eg4uOTYac05EGWre9vRkvrclCWS07VxMRERGRiwXb0untrLPOQmxsLE466SRceuml+NnPfoYRI0bgmmuu0W5wF198Me6//35nrSK5oHWZJfh4S4Fev/6ENCSzIRoNAqmcOHtKIv541gRMSAzT6oqvdhbi1rc24pV1B3CokpluIiIicn2ZmZnw8fFBREQE6urqunzc+PHjtUnYp59+2uvXkG7e8m8PHDiA999/H3PmzNFqZRkaLFM6d/ecsk4PP/wwpk2bpo8PDAzUdbn33ntRXl7e6b/58ccfcdFFFyEpKQlGo1Ffa+TIkTjvvPO04bYzOW3qr6ysLDzzzDPYsGGDXpcx2rIqcXFxmDFjBpYsWYLTTjut2+ewT/21bGMWu5EPAdKg6v6l29HYbMGZk4fh4hkpzl4lGqJ2FFThnQ252HWouvW2pIgATE+NwPThkRgRHeSQoQ2c+mvwceovIiL3nvpL4gpJ3nHqr66deeaZ+Oijj/DCCy/gF7/4xRH3r1y5EieeeCLS0tKwd+/eXnfmlmA7Ozsbt912G5588klMnz4dGRkZGuj/8MMP+hiJA2+66aZ2/66srAwLFy7UCmgJmCUwlwrnVatWoaSkRP+uK1as0Oe3W758OU499VSYTCadMlpex2w24+DBgzqr1eLFi/HBBx/0aL0HYvtxyXm2e4rB9tBR09CsHaGLqhsxKTEMv108Bt7eHKdNziNfnVsPVmqlxY78KpjbfJWGBhgwLMwfcaH+iA3x08uoIKMOeZAl2M8XRt+jFxYx2B58DLaJiDw32JZ9d73JDHcUYPBx2HRUX331FRYtWqTBqQS2HZ1//vl477338Je//AW33357r5/fHmx7eXnhtdde0wpmu7feekurlyW7vnHjRkyYMKH1vp///Od6/8yZM/HJJ58gKsr2t66pqcGFF16Izz77DMcffzy+/fbb1n8jJwXk5MC///3vdq8jKisrsXPnThx33HE9Wm8G2x0w2B4aLBYrHv1iFzbnVWrg8qezJyLYn+O0yXXUNDZjU24FNhwow+a8CjSYLEf9NwYfL1vwbbQF33I91N8XMSF+iG0J0k+dGI+YYD/OFTqIGGwTEXlusF3X1Ixx930Bd7TjD6cg0Oi4418Jcrdv345vvvlGy7zbTrks75+UY0t2ODw8vM/B9tlnn61l5F0F85JVl+y6yMnJ0deV0FROAEyaNKndv5F1SU9P17+xBNsSdAspMd+xY4dmxaU0vj8GIthmxEIuTT5wr3+frYG20cfWEI2BNrkaCZbnpEfr0tRsQU5ZLQqrGlFY1dCyNKKy3oTapmbUNjbDYoV2N6+oM+nSFRk2IWeykyMDkBwRqD0KUiLbXgY4dMdLREREQ4M0ob7uuuvw17/+tV2w/Y9//EMbWMuQ3r4E2m1deeWVXd4uwfbXX3/detvq1au1UbaM1e4YaIvExESccsopOgZbMtn2YFuGH0uwLVltabAtWWxfX9c5NnKdNSHqwGK14uW1B7BsR6H+fO28kUiNCnL2ahF1S8rD02NDdOmMvYRNgu6aRtulXm9qRmWdSYdKFFc3oqi6AaW1TfrYPYU1unQmOth4OPiOOByMSyCeEBYAHw63ICIiUnICWzLE7rrujnTZZZfhrrvuwn//+18UFBQgISEBTU1N+L//+z+9/8Ybb+z3a4wYMaLb2yWL3jZz3d2/ETKGvO1jxZ///Gds2bJFS8xlCQgI0IBdxntLAD527Fg4E4NtcknS7fkfqzLxzb4SSKhw9ZwRmJ0e7ezVIuo3KQmXbLQsMUcZ/XJMagTyK+qRU1anS255HXLt18vqNVsu883LsjGnotNS9cTwgJbgu31ALktYIKdVJCKiobcPJmiXbynjfvTRR7WUW2aAkmxzYWEh5s6d22l22dGsDhjNHB8frw23pYmajEWXEvPvv/9eLx966CENxn/729/CWbi1kcsxmS14ZvlebMguhyTlfjU/nYE2Ddks+fDoIF06I5nwtgG4LSCv15/zyuu0VP1AaZ0unQnx9z0cgEe1ZMQjAvS2xIgA+Pk69iw6ERERuY4bbrhBm6BJsC0l2FJS7qistsjKytImbB3JlGBCpupqWyYu9u/f3+Xz2e+zP7btSRTJZMtiH3v98ssv6+8nv5eMEbdnxQcbg21yua7jz6zYq12eJSt3y8JRmt0joiNJZjosMEzn/u6sOkTGi9uD8LwOAbmUqlc3NGN7fpUuHUlPtvhQ//YZ8aiA1uvSyI2N24iIiNxXSkqKNjGTjPZ9992HtWvXYtiwYTj33HMd8vyvvfaaPn9Hr776ql7ag2Mxb948eHt7a3M0mbKrY5Aupe6ff/65Xl+wYEG3ryvNzX75y1/q+HN5PikzH9LB9jvvvIPnnntO31gZKyCd5qTGXuZmk7nVaGhks7/YfggfbDyI2iYz/Hy98euTR3caRBDR0clY7WHhAbocNzKq046seS1Z8NYgvOzwzzJWvKCyQZcfssqO+Pf+Bu8jmrZpVlwy5BGB2l2diIiIXNstt9yiwfbDDz+sP0vTNEc1GHv//ffx5ptv6pRedu+++66+nrxG23m2JfC/4IILdOovWYe2U3/V1tbi2muv1Yy1NEazN0cTjz/+uE4LJv++rV27dukc4SI1NRXO4vSpv2699VY8/fTT+obLPGnBwcE6WXlFRYV2xvvyyy91oHtnOPWX+5PN77v9pXhzfa42hhJy0H7dvJFIiwl29uoROZWz5tmWz6U0Z7MF4B3K1MvqUVBZrx3VuyPzirftmn44IA9EQpg/fH2OPs+4M3DqLyIiz536izonDcVkzmtJcsoUXDIOuj/sU3/deuuteOqpp3DsscciIyMDmZmZOp5aPPHEE5pYbau0tBQLFy7UBKzEeJLBlhhRxmMXFxfr31XiRHl+O+mYLvNpjxkzRpuhSdyYn5+PNWvWaFf1K664Aq+88srQnPrrgw8+0EBbAmx5E+UPLUpKSjTwljfpd7/7nZ6xIM9R32TGrkO20lWZk1iyayI80IALpyfjhIwYeLODMpHTSHl4dLCfLtNSjhzGIdObSeM2GS9+uEz9cCM3adwmwbosMv94R74tWfe2ndPtTdskGJfvApaoExERDY6TTz5Zg20Z29zfQLtj1vz444/Hk08+iaVLl+rJfGm+duedd+L0008/4vGSyZZS9meeeUYz3JJ0lenAJPiVZm6//vWvj5hLW6qjly9fjvXr12s8KVlw+R0WLVqk2fCzzjoLzuTUzLbMiyZvzIMPPoh77rmn3X0SaMsfw8/PT7viydmNjpjZbj9NlszXW1LTaFtkPGZjszZIajZbtEzbJKko+Wt76f91kYGZrdf1Z8Dby0sPhqUMVS4lAyXXfdre1vqzd7vH+vjY7/PW5mYyBru8zoTK+ia9lAP0zOKadlkxKRk/Y/Iw/GxiAvwdPK0BkTtzVma7vyTYtmfEDwfk9TpuXE6uNZkt3f77ED/fI4LwpJZL6a4+kN8TzGwTEbk2ZrYdy2w263hmyURLoDtr1qx+P6c9s52VldUuC+3qPCqzLfOjSaAtLrnkkiPulxLy5ORk5Obm4tNPP8XFF1/shLV03cD6UGWDBq37imr0Ug5mJbB2F7Ehfhg/LAzjh4ViYlIYQv05Np/IU4QFGBCW2H3jtsNTmNkattmz4tq4rbEZOwqqdOlIEt5xIf6dZ8UjAxET7MfKGCIioh6STuQSGEuQ7YhAm1wk2JZSBREZGdnl5OXTp0/XYFseO9SDbWlmtCWvEj9ll2NjbgVqGps7PQiVcZL28s/QAAOMPt7a1du35VIOQSUkt9czyKVVb7FfBywWK5otVj0oNlssemn/+fCl7Xb7bc3mlsdbbZl0+/Ugoy8iAo1aFhoeKOtmxJj4EMSE8Gwj0VBv3Dazk8ZtMsxEpi2zB+KSEdcy9Zbb6prMOFTVoMsPB45s3CaVMm2nMGs3x3hkIILZuI3akH3pgZJarbpqMJm16kJOXMtQCWvL9mRbfOBn8NaqCvttct3Q0ntAigQP71utrdVbcnJc7tD7bA9sM9evT8viiwCjj1aVERENht27d+Oxxx7DoUOHtMO3dAHnsN2B4bSjDknRi46d49qSzHbbxw41tY3N2jzs+6wyzfBIAGsngfPI6GCkxQQhLTZYr8tUPHIgS0TkriToyIgL0aUjCWjKWhq32QLweuSU2qczq9OAqbHZohU/snQmsqVxmz0YtwfhcimN28izldY0Yt3+Ut0+skpqWxtzuoLwAIMOl5Bt097pf0R0EPfrRORwMo3WSy+9BKPRiPHjx+OBBx5o1+HbTvpoyTjpnrrmmmu0OplcINiurq7Wy6CgoC4fI43T7GOzu1NTXaUHYQajEUY/P7gzyRhvzavE6r0l+CmnvF1puMx5e0xquDYsyogLhq/3kd18ndxcnogciJ/nzoNlWaYkhx9xn/SmsDVus2XDcztMZ1ZRb9JgXZbNnTRuk6BGnjvQ4KMZSVlkeLn9ulT9yDlPuS5/mdZeFbJ4eemJAhkSE+LvixB/A0IDfLWsXYbNxIb6M6vuxBPXMn3dmn0l2HnIduzRlpyolpMtQUZbptrYkrkWcvJGFsl663X7pS5mzYDb+5/YY2Ivey8U7Y/i1XJpv0//q9uQVHFIpYa9h4FsnxUHK7HtYGXrukUGGnDi2DicODpGq8OIqPt9o/0+rTbhPrRLJ5xwgjYea6uz90vitZ528rY/7+zZs9slSq1u9Hfo7fbTk2auHrHnP2eebdLzJTfcjqtvvAPuRna6+4pr8V1WBb7LKkdVw+ES8aRwf8xOi8QxKWEY1jbrYmlGh88IEXkYadRBvRMX5IO4oGBMTzpy6sDqhmbktQTjB8sb9FJ+zitv0Es5uSljxgeKlAzHhhgRqwG4UYM8uZThPxJUsUGk48iJl015VVi7vwwbc6t0uJPdmLhgTEkKxfCoQAyPCnD6SRBZVwm6S2qakNuyLco2mVVah7I6E979MQ/vbzyIGanhOHlsDDJiu05SEA31fWNjY2NroOROQZ6rkvmppYFab7jz+25t2W5kO+qJrqanbstpe5iQlu7h0p69KzU1tjLA0NDQbp/r/dWbERQcopltb1/3OPMrJeFSwiZn27/LKtWdrF2ovy9mp0djbno0UqMCOQUO0RDFTqqOJW9nTHgwpnbSGFWy1oXVDfh82yHNWkqmWsbQSrM1yVjKdZ+W6/ay3sO9LWx9K+pMzRrQ2xaTzhBRXNOopcpyXQKqA6X1unQmwOCDyCCDZtdjQ/wRH+avpe1S1RQb6tdpNRMdJlnmvUXVWJtpG34l77edlGbPSY/G8WlRiAp2rQo4ifWlKC8iJAgZCe2DcPk9lu0oxN6iGqzLKtfllHFxuPS4FG4PNGQdbd+o1SUtC1Fv2LcbmQ3L7buR29vASwO0rtjvO1rL+OCQUJef+ksanEk5485DVdhZUIU9hdVoMFnaHWRNHx6BWSOjtDs3d6JExAOFwSPTFg4LD8TYhCM7qDuClBwXVdkC76LqBhTK9aoG/bm0tlH3B/UmMw5WyCJZm/bDpyT4Twj317G8STKmt2VOcilRd+fu67JvPFBap2Opq+qbUdVg0pMVtU3N8PPxRqCfr5Z3S4m+7CftU1DqiRAvLz2ZkV1ai+zSOuRX1rc2/xRy0mJ2WpSevE6Ncr9ssNHXB3MzYnSRk/NfbD+EVXuK8cWOQmSX1eGWhRksLachqbt9o/0+BtvUFwOx/Tgt2J46dapelpaWts5n1tGGDRv0ctq0aXCFUm85Sy5jv+RSDpwaTRY0tFzqzzquy3ZdxnfJuEDJWMu8123PsNvJAYRMjTM7LRqTk8N1nBgREXke6WZt74zeVdBZXmtCWV2TBp4yPVpBZYNO8yid12X/Ig3hZGlLmmUmtQTgSeEBiAz2Q0SgoXUWCAlQXeWAs6ahGVmltRo4ZpXU4EBJnf5ujiSVYcekRmJOehTGJIR6TIdvaZT2yxPS9KT88yszsetQNe5+fytuPWkURnXSTJCIiFyD04LtpKQkHHvssTrX9htvvIF77rmn3f1r1qzRzLak8U877bRun+vqV9bD1z+w3dluCVzt02oEtUyrYZ+mw978RBrb2Keosk9hJc1PaluCatsiPzdrIxOrA+aeHR0fgrHxoRibEKJZCXfOSBARkWPI9E+yJEYcOf5Lxo+V1jbp9Gfa8K3c1oldfpZx5rbgtfMhWbJf9Jd9nsFHp4LU6atkGiu9TfaHPnq/wdfbdr9ctly332bfZ3Z6W8vP8joS1EuTTzlpICcMSmqbNHsvWWdZP8lCd0amhJRS+ZAAgzaYk4BZxlFL4zDZB8uJCNkvy/7Zvs+2T1EpJxQkay3jr1Mig/REg6ucXBgI01Mj8eDZAXhi2R4crKjHHz7egatnj8CJY2KdvWpELsWdxw2TZ203Tu0Kcvfdd+Occ87Bww8/jFNPPbU1gy3Z7l/96ld6/cYbb0RY2NHL+rRDrHbutr1JUo5XWW9y+DrLwYUG7vY5N9sctOg8nC0HNf4Gb0QGGnVsmHSjjQo2svkNERH1mgSP0cF+ukxJjmi9XQJOKUOX4Fs6rksmvLyuybbUmnQ/KMGpnkDupLrKsesIDbolQO7uWCUu1A/Do4IwMjoIw1sWCbCp52SO+j+eNQH/WJ2pY7r/75v9aDZbcPL4eGevGpHT+fraQhtpcNWT5lVEbdkbo9m3I0fwsjr51M8tt9yCZ555BgaDAQsXLtSpwJYvX46KigptHb9s2bIuPywyJZgE4u+u3Q3/oJDWqVnkrLc0SpHSbdtiy1A3Sam32aL3ySJnxe3jv+zTt8jBgpxRD9LFlhW3XbeNG/P1Yak3EQ2OWWlRzl6FIWddZik8hQxnkgqthpYpq2S/p9dbhz8dHgKl+0WzBaY21+23S6Ourm7r7ABC9qdygjkqSE4Q2OY1lzJoCbJlX0qOIYdvb23IxYeb8vXna+aMwMKxcc5eLSKn7xtzcnLQ3NysnbR9fJjoop6RruvZ2dkaaKekpMBRnL7Xe/rppzWofu6557B27VqYTCakpaXhrrvuwm233aaTrR9NWIARQUFsEkJERGQn1VQDWVElwZ4Ov2oTgEtZuQyZ8pSx0q5e8XDR9GStXvh4SwFeXJOlSYP5o1lSTkNbdHS0DkWVnlCSlJOknQTdnjzEhPq+H5Mgu76+HpWVlTr3eEJCm2khPCGz3R/2zPayjVku342ciKi3mNkefJ6U2aahQQ7jXv0uW6etk1Di+vlp2sGcaCjvG5uamlBUVIS6urpezxNNQ4+Pjw8CAwMRGxvbo0SvW2W2iYiIiKhvJFt3xXGpOtf7VzsL8bdVmVpZIFOeEQ1VEjBJM2Y5GSVVs5KxJOqMt7e3DmceqMoHBttEREREbkwOEpfMHq4l5St3F+G5lfu0vJ9dymmok8+GozOVRL3Bbl9EREREbk6y2dfMHYGTxsZq4zrpUv7p1gJnrxYR0ZDGYJuIiIjIQwJumXf79Em2Bj+vfZeN937K45zDREROwmCbiIiIyIPKZi+ZkYILjknSn9/9MQ+vf5+j06MSEdHgYrBNRERE5GEB97nTknD5can68ydbC/DHj3fgUGWDs1eNiGhI8XbmjqC75ec//7mzVo2IiIjI7Z02MQG/mp8Gf4M3dh2qxm/f24LPtxUwy01uparBhN2Hqp29GkTu2Y38yiuv7PT2mTNnDvq6EBEREXkSmXN7THwI/rF6P7bnV+GVddn4PqsM/zNnBJIiAp29ekRdqqhr0qqMZTsKEWD0wdMXTYXRl0W55F68rE7qmmGfy6w/L19VVYWwsDAs25iFoJAQB64dEZHzzUqLcvYqDDnrMkudvQpEA0KOt77aWYQ3fshGg8k253BaTJDOxz1rZBTCAzk9ErmG0ppGfLSlACt2FcJktsUJI6KDcMvCDMSF+nPfSG7F6ZltIiIiIhr4JMeicXGYkhym2e2fcsqRWVyri3QtH58QiuTIQIQHGBAWaNTLID85TLTCYpVg3RawS5gul/KzvRxduqB7e7Vcest1L/h4t78NLY+3LS3XLW2uW63w9fZGaIAvQv0NCDT6tCZmaGioa2rWhn6SyW6WDQNARmwwzpmaiCnJ4dweyC0x2CYiIiIaImJC/PHrk0drie53+8uwNrMEe4tqsC2/ShdXIcF6WIAB8aH+GBkTpJlNWSSzKQE8eQ450fLN3mK88UMuqupNetvYhBCcOzUJ44eFMsgmt+b0YPuJJ57Avn379IOUkpKCRYsWYdq0ac5eLSIiIiKPJWXjiyfE61JY1YCNORUor2vSpbLOhIp6k2YaveR/LRlqudQFtqx12yGBZs1Ut89emzVzbctgw57lbpsF16z34esmswXVDc2oN5n135bVNumyo+DwSYAgo49mOWeMiMLk5DD4+fo48V2k/tpfXIOX1x7QEz5iWJg/rpg1HJOTw529akSeMWa7M4sXL8bLL7+MuLi4bp+DY7aJyJNxXNrg45htIudrarZoB+qKOhNyy+qwv6QWWSU1yCmrax3DK4w+3hp4z0mPxvThEcyAuhE5kfPW+lwtGZe/qHTMl0z2qRPi4evTfRM07hvJnTgt2L700ktx4YUXYsqUKRpU5+bm4ssvv8T999+P0tJSTJw4ET/88AP8/f2PGmy/v3ozgoJDYDAaYfTzG9Tfg4hooPCAYvAx2CZyXc0WCzKLarEhuww/ZJWjuKax9b702GBcNjMFo+KYfHFlEnb8cKAMr67LRnmdrWT8+LQoXDIjBZFBPWvSx30juYqenODrdbB95513YunSpb1emRdffBFz5sw56uOysrIwdepUVFZW4sknn8Stt9561GDbbskNt+PqG+/o9boREbmiY1IjnL0KQ86P2eXOXgUi6gE5fM0uq8d3WeVYtqsEjc22DuvHDQ/HRccMQ0wIky+upri6Ea98n4dNebZhAXEhflgyKwkThoX26nm4byRXERAQ4Pgx2/n5+di9e3evV6amxjYW42hGjBiBJUuW4KmnnsJHH33UbbBt1zaz7e3LqSuIyDN0V9lDA4P7ECL3MTLODyPjwnHqpES8syEPq/YU47sDFfgxtxLnT0vC6ZMSWFruIhUJn28rxHs/5elJEWl+d+bkYThr8rA+zZvNfSO5k14H2//+9791GUhjx47Vy7y8vB49PjgklGO2icjj8CBx8PE9J3I/kUF+uO6ENG32JtOYbc+vwn/W5yKvoh6/mDsShqOMAaaBs6+oGi9+k4Xssjr9eUx8CK6ZMxKJEUfPCHaF39PkTpzejbwzMmZbhDCAJiIiIqIeSI0Kwj2njcWynYV4Ze0BfLO3BEVVjbj95FE6dzc5rwFasJ8vLp2ZghNGxTBYpiHF5YJti8WCt99+W6/PmDHD2atDRERERG5CArmTx8UjLsQfTy/fi92F1fjdB9tw5+IxSAzvezaVej6WXk5yvPFDDipb5syemxGNy2amIjSAJzxo6HFKXc3rr7/e6bjvoqIi7VK+adMmGAwG3HTTTc5YPSIiIiJyYzJP8x/OGo/YED8UVTfivg+3YdvBSmevlkfLLq3F7z/agb+tytRAOyHMXysNfjU/nYE2DVlOyWy/8847uOyyy5CRkYFx48YhKCgIOTk5GmRLI7XAwECdZ9s+dpuIiIiIqDeSIgLxx7Mm4IllezTD/fDnu3DdvJGYmxHj7FXzKBV1TfhgUz6+3HEIMseRn6/MmZ2I0yYmHHXObCJP55Rg+8orr9Tx2BJcf/vtt6ioqNDW6enp6Vi4cCFuuOEG7UpORERERNRXklG9+7Sx+Nuqffhufxme/zoTpbVN2gmbY4f7p7yuCR9vzsdXO4vQZLZNvTZzRCQuPy4VUcGceo2oT/NsuxL7PNvLNmaxGzkReZxZaVHOXoUhZ12mrUEnEXkWi9WKN77PwSdbC/TnhWNisWT2CJ2GinqnsKoBn207hBW7CmEy28KItJggXHRsCiYmhg3463PfSO7E5RqkERERERE5kreXFy47LhXRwX54dd0BLN9VhJKaRlw/Px1hHE/c7RzZZTVN2HmoCjvyq7CjoAolNU2t94+KC8a5U5MwKSmMlQJEnWCwTURERERDgszFHRVkxLMr92JzXiV+8+5mnfd5xohIuAuLxYqqBhMq6k2orLNdVjeYUNtoRm1TM2obm1HXZEaz2aLTbtlrWK3yP/v1DrfZHme7scFk0am75Dkam23l4W35eHlh7LBQLcUfPyyUQTZRNxhsExEREdGQceyISPwxdIKO384pq8OTX+3B7PRoXHX8cJ0PeiBJQCtBsYx3lo7d9U1m1JnMaDCZ9Xp9h+utP7fcJoGw/DyYY0AluB4ZE4Rxw0IxLiEUo+JC4G/wGcQ1IHJfDLaJiIiIaEhJjQrCn86egPd+OogPNx/Et/tKsCO/EhdMT8askVH9CiYly5xf0YCi6gYUVjXqZVFVI8pqm1BR39Q6zrk/JJccEmBAeMsi14OMPnqyIMjPF4FGHxhaOoFL4tmWe/Y6fF0vvQ5fb/Ozn8EbgUbbc9gWX45tJ+ojBttERERENOTItFQXHZuMY1LDNctdUNmAF1bvx2vrsjEnIxonjonF8KigLv+9ZJgPVtRrdjyvrA655fXILavTsu6jCfLzQXiAUS8lsA9oWfwluJVL+dnYclub67afvRHib2AATOQGGGwTERER0ZCVHhuCP587EV9sO6SN04qqG7FsR6EuSREBmjn2M/jo/NF+vj6auZYAu7i6sctybhkXHhfqj7hQP8SG+CM21E+bs2kmOtAIoy/nnyYaChhsExEREdGQJkH0mVMScfrkYdieX6XTWq0/UI688npdupvHOzkiAMmRgUiOkCUASRGBmokmImKwTURERETUMkWYzBUtS1W9CXuKqrUpWaPJ1plbSsdlHLME1xJUc9owIuoOg20iIiIiok6y1tNT3WdKMCJyPW4dbNvnA6ytqXb2qhAROVxVFTMmg622mvsTIiJXxn0juZKQkJBu55r3stojVjeUl5eH5ORkZ68GERERERERDTGVlZUIDQ31zGDbYrEgPz//qGcUiIiIiIiIiBzJozPbRERERERERK6Ik/wRERERERERORiDbSIiIiIiIiIHY7BNRERERERE5GAMtomIiIiIiIgcjME2ERERERERkYMx2CYiIiIiIiJyMAbbRERERERERA7GYJuIiIiIiIjIwRhsExERERERETkYg20iIiIiIiIiB2OwTURERERERORqwbbJZMLy5cvxm9/8BsceeyzCw8NhMBgQHx+PM888E5988kmn/+6BBx6Al5dXt8uuXbv6u3pEREREREREg863v0+watUqLFq0SK9LgD1nzhwEBQVhx44d+Oijj3S59tpr8fe//10D6I4mT56MKVOmdPrcYWFh/V09IiIiIiIiIvcLtr29vXHeeefhlltuwdy5c9vd99Zbb+HSSy/FCy+8gNmzZ+OKK6444t+fffbZmuXuC6vViurqaoSEhHQayBMRERERERG5ZbB94okn6tKZiy66CMuWLcNLL72EV199tdNguz8k0Jbs97KNWQgKCXHocxMROdustChnr8KQsy6z1NmrQERE3eC+kdzJgDdImzp1ql7m5uYO9EsREREREREReUZm+2j27t2rlwkJCZ3e/9NPP+Guu+5CWVmZZqklOD/jjDO0NJyIiIiIqDeazRbUNZnR2GxBkyxmC2S0YUpEILy9OeyQiDwk2D506BBefvllvS7jujtjb6LWlgTdzzzzjMPLzomIiIjIc63cVYTXvstGvcl8xH3Bfr6YmhKOY1IjMCkxHAFGH6esIxENHQMWbDc3N+Oyyy5DZWUlJk6ciOuuu67d/WlpaXjooYdw6qmnIjU1VW+TDuYPP/wwPv74Y1x55ZXw8fHRBmtHU1Ndpc3SDEYjjH5+A/UrERENKvleo8HF95zIPUkG++W1B/D1nuLW2ww+XvDz9YHR1xsNJjNqGpvxzd4SXXy9vTAnPRrXzBnBbLeb4fc0uYqeNOj2sg7QFnvNNddoY7SoqCisXbsWo0aN6vG/vfnmm/Hss88iJiYGeXl5MBqNnT6uqqqq3fRgS264HVffeIdD1p+IyNkk+0KD68fscmevAhH1UlF1I55emYXssnotFz9/agJOnxAHnzZBtNlixZ6iGmzMrcKPOZUorG7U2y85NhGnjY914tpTb3HfSK4iICDAOcG2TAMmZeARERFYvnx5a5O0npLx27GxsTCbzVi9evURU4p1DLbfX70ZQcEhzGwTkUdhx9XBx27kRO5lc24Fnl25T8doh/j74sYF6ZiYeDgR0xk59P1qZxH+tfaAZr8fPnciEsKOftBMroH7RnKnzLbDy8jvuOMODbTDw8Px5Zdf9jrQFpGRkRpsFxQUaGb7aIJDQjn1FxENyS9xciy+50Tuo7rBhKeW79VGaBmxwbhlYQaigv169DlfNC4OG7LLsfVgJf6xej/uP308y8ndBL+nachO/XXnnXfiiSee0GyzBNrTp0/v0/NIRlvGegt2JSciIiKijlbsKtJAOzUyEPedPq5HgXbbgO3aeSMRYPDBnsIafL790ICuKxENTQ4LtmX6rscee0wD7WXLluHYY4/t83MtXboUdXV1+kXY14CdiIiIiDxTs8WCL3cU6vVTJybA16f3h7TRwX64dGaKXn9zfQ4KKusdvp5ENLQ5pIz83nvvxSOPPNJaOn60QDsnJ0fHYp9//vnw9/dvd98HH3ygzdWEdCKPj493xCoSERERkYdYn1WOstomhAYYcHw/xvCeOCYW32WVYZuUk6/arxlylpMPDTJzkiw0tHl7e8NgMAzY8IR+B9uShf7Tn/6k19PT0/Hcc891+rjo6Gg8/vjjrQ3QLr/8clx//fU6pjsxMRH19fU69dfevXv1MQsWLMDf/va3/q4eEREREXmYz7cX6OVJY2Nh6ENWu105+dyRuPO9zdhdWK3Z8sUTmOjxZFI9W1JSgtraWmevCrkICbZl6LLEqzL1tEsF2xI4223YsEGXzshc2vZgOzk5Gb/97W+xfv167Nu3Dz/99BOampr0Fzz99NNxySWX4KKLLtIzDUREREREdpnFNTrOWqb2WjQ2rt/PFxPih4tnpOBf3x7AR1vytXla22nDyHNIvJGbm6vBVUJCAvz8/NhwbQizWq3aK6ympgYVFRWa/JU41ZEBd7+D7auuukqX3pC5tx9++OH+vjQRERERDTGfbbM1M5s1MgrhgUaHPOeC0bF498c8LU3flFvBuZw9VFFRkQZSkgR0dAaT3FdwcLD2HZOhzlL1EBfX/5N4dkwdExEREZFbKK9rwnf7S/X6qQ4s95ZS9BNGxej15TttjdfI87KYUkIuQRUDbeooICAAoaGhqK6u1m3FURhsExEREZFb+GpHIcwWK0bHhWBkTLBDn1uapQnJbBdXNzr0ucn5TCaTlgxLUEXUGRm3LduJLI7CYJuIiIiIXF5TswVftWSdB6KJWUJYACYMC4XktFbuLnL485NzWSwWvWRWm7pi3zbs24ojMNgmIiIiIpe3NrMEVQ3NiAoy4tjhkQPyGgtbGq5JsC1zeZPnYUM0Gsxtg8E2EREREbm8Fbts2eaB7BY+PTVC5+6uqDNhY3bFgLwGEQ0dDLaJiIiIyKUVVNZjb1ENJPE0r6WR2UDw9fHG/Jbn/2oXG6URUf8w2CYiIiIil7Zmb4leTkoMQ4SDpvs6WqO0LXmVKKxqGNDXIqKBKwl3hSEDDLaJiIiIyGVZrFZ80xJsz80YuKy2XVyoPyYlhbUrXSci6gsG20RERETksvYcqkZxTSMCDD6YPjxiUF7zpDG2Rmlf7ylGs5mN0oiobxhsExEREZHLWt2S1Z45IhJ+voMzbdPU1HCEBxpQVW/Cj9nlg/KaROR5GGwTERERkcvOrf3d/lK9PncAG6N15OvtjXktJetr9tmCfSJPd9NNN+k457lz56K5ufmI+++55x69f9q0aWho6Hk/g4qKCgQEBOg81gcPHuzyceeff74+/9NPP33Efe+++y4WL16MmJgYGI1GJCYm4rLLLsOOHTvgyhhsExEREZFL+jG7DPUmM6KDjRgTHzKorz03I1ovN+ZWoLrBNKivTeQMf/nLXzB9+nSsWbMG9957b7v7Pv/8c/z5z39GaGgo3n77bfj7+/f4ecPDw3HOOefAYrHgtdde6/QxpaWl+OijjzSQliDaToL+iy66CBdccAG+/vprjBo1CmeffbYG3a+//rqur6ybq2KwTUREREQuXUIujdG8B7mzcFJEIIZHBcJsseK7/WWD+to0uKxWK+qamt12kfV3BAl0JZCW4PjRRx/FZ599prfn5eXh8ssv19d58cUXkZ6e3uvnvvrqq/XylVde6fR+CZybmppwxhlnICoqqvX2+++/X9dp5syZ2LlzJ7799lv9edOmTXjnnXf031xyySWaPXdFvs5eASIiIiKijirqmrAlz3YAPTfdlmUebHPSY3CgNBtr9hVj0Thb0zTyPFI9Me6+L+CudvzhFAQaHRPWjRgxAi+//LJmjyXAXr9+vV6WlJTgxhtv1AxzXyxcuBCpqanYtWsX1q1bh1mzZrW7/1//+pdeLlmypPW2srIyPPnkk5pFf++997R0vGPZ+XXXXYfnn38e//73v3X9XA0z20RERETkctZmlsJiBTJig5EQHuCUdZiVFgVJqO8prOGc2zRknHXWWbj99tu1tHvq1KmaTZZybSkz7ysvLy9ceeWVel2C+bYkSy1LQkKCjsu2W7lyJerr6zF79uwjAm27+fPn6+XatWvhipjZJiIiIiKXs3pvcbux084QGWTEhGFh2HqwEt/uK8G505Kcti40cGRaOckOu/P6O9ojjzyiY6GlAVlQUJCWbkuZeX8sWbIEf/zjH/HWW2/hqaee0qZpbbPaV1xxhTZRs9u/f79eLl++XIP17hQX274vXA2DbSIiIiJyKdmltcgurYOPtxdmjXResG0P9iXYlq7k50xNPOpBP7kf+Zs6qgzbU3z//ffYs2ePXq+trcXWrVu1xLw/hg8fjgULFmDFihV4//33day1yWTCG2+8cUQJuZCGakLGiEt2uztjxoyBK+JWRUREREQu5Yvth/RyemoEgv2de7h67HCZ3zsLBZUNyCyuRXpssFPXh2igyfjsn//859oJXAJgKfu+6qqrsHHjRh133R9LlizRYFuy2RJsSwdyeb3jjz8eo0ePbvfY5ORkvZTbO5aeuwuO2SYiIiIil1FVb2qd2/q0iQnOXh34G3w06Becc5s8nXQcl4Zo0oFcyrr/+c9/4o477kB5eblOwSWZ6P4477zzEBYWpgF3bm5up43R2jZVk9J1mfKrqKgI7ojBNhERERG5jK92FsJktiItJkibo7mCOS3jxtdllqC5pbSVyBPJXNoyVnvcuHHa5dt+m3QPl9LyO++8s1/PHxAQoFlzKRG3jwsPDAzUQL6juLg43HTTTVrGLlOCSSl7R42NjVi6dKl2OXdFDLaJiIiIyCU0my1YtqNQr586IcFlxkdPTAxHaIABVQ3N2JpX6ezVIRoQq1evxn333afBr8xhLY3RhK+vL958801ERkZqY7MPP/ywX6+zpCWL/dxzz2mpukzhFRIS0uljH374YS03/+GHHzBlyhRMmzZNHy8B+5w5c3RObumefuDAAbgiBttERERE5BLW7S9FRb0JEYEGzBwRCVchjdqOT4vS6ywlJ08k3bwvvvhimM1mDYIls91WSkqKjpuWE2ASLPcnuJ05cybGjx/f+nNnJeR2Eui//vrr+PTTT3Xubyknl0z2F198ofNwS8ZbGqzNmzcProgN0oiIiIjIJcaKfrbN1hjt5HHx8PVxrZzQnPRofL7tENYfKENFXRPCA/s3DRKRK4mJicHBgwe7fYwEtvYO4f21bdu2Xj3+1FNP1aU33yeuwLW+xYiIiIhoSNpdWI2skloYfLxw4thYuJqR0UE6jlzGk3+8pcDZq0NEboDBNhERERE5nT2rPS8jBqH+BrgaKZ89/5gkvS7jyiW7TUTUHZaRuxiL1Yr6JjPqmppR02hGbWOzzi85PMrWoICIiIjI0xRVNWh5tlg8IR6uanJSuM6zva+oRrPblx3XvzmHu1Ja04ht+ZXYWVANX28vjIgOwvDoICRHBMLoy1wZOZfMi/3rX/+6x4+/5pprtJnZUMRg24WC7A82HsSHm/LRZD5yLMTExDBcPCNFv2yJiIjcXXG1LZjYfagaEYFGnDohXrs909D0xY5CyBDLSYlhSIoIhKuS7PZ505LwyOe7NLt9+qQEh4zdluPAHflVesJBPhf5FQ2dPs7HywspUYFYPD4eczOiXaZbOw0tNTU1eOWVV3r8+Pnz5zPYJuepqjfhuZX7sOXg4akkZLxSkJ8vgoy+OFTVgK0HK7H1/a2YNTIKF0xPQkJYgDNXmYiIqNf7uu35ldieX6XBRGFVY7v7P9tWgFPGx2vwEuLAEmKZE9lssbYuEtCF+PsySHEhksVdvrNluq+JrpvVtpucFOaw7HZhVQNW7ynG6r3FKKk5XJYum6eMEZ+QGKbbrIxll6WmsVkv/7YqEyt2FeHqOSOQEum6JyfIMw0fPtxlGpC5OgbbTiZn9J9ZsRdltU0w+njj6jnDMWtkdLsSIfkifufHPKzdV6JTYvyQVaY7o58fm6JTURAREbkai8WqJ5G35lVgW34Vcsrq2t0vu6+0mGCMTQjFtoOV2F9Si6Wb8/HljkNYPD4BZ0xOQKCx74cpJTWN+PuqTA3uOxoTH4I7Fo3WYVrkfK99l43GZgsyYoMxKSkcrq4/2W05+bO/uBY7CqqwObcCuw5Vt94XaPTBzBFRmJIcjnHDQhHs1377lOCmtLYJ3+4rwfsbD2pDuf/97xbNcp93TFK/Pi9ENDC8rG58WqKqqgphYWFYtjELQV1MhO6q5G3/dOsh/OeHHJitVgwL98etC0chuZuzk9mltXhzfS425Vboz+MSQnHzwgyEseyOyCPNapnTlQbPusxSZ6+CR5AMtgRQ2aXtA2zJwI0fFooJw8IwJiGkNTiQfeJPORV498dcHGj5N7Jf/PWi0UgI730ll5yUfmF1JmqbzF0+Rtbl7tPGch/qZHJMI0GrnHx56JyJSHWTHjWyzd6/dDv2FtXgtIkJuLyb7HaDyYyvdxdjY265JlnkxIKdpEwmJoXhhFExmJ4a2ePx2FIN8Op32bqti8ggI+4+dSwSIzy/8rGv+8aGhgZkZWVhxIgR8Pf3d/h6kftrGIBthMG2E8hbLgch9q6bx6dF4RdzR8Lf4NOjfy9frH9btQ8NJguigoy4bdEozQ4QkWdhsD34GGz3T0FFPV7/IQc/Zpe3ZuqOGxmFCcNCMW5Y2FEDW9k/bjhQjpfXHdCKL/n3N52YoZm+nmhqtuC17w7gq51F+rNM03T9/HTdV0olmIx3PVhRjz99uhOV9SYN6O85bZwGKjT45O/1m3c3o6i68agBqyuSzPTDn+/SysSnfz7liOy2BNmS+f54Sz6qGppbb5eMtSRMpKrj2OERiAr269c6/Gttlg7LCA804P7TxyM+zLMDSQbbNFA8Nth+55138Nxzz2Hz5s1oampCeno6Lr30Utx2220wGAweFWxLWd1L32bpOBshOxZpCtPbsWMHy+vxl2W7UVDZoOO7r549AvNHu96clETUdwy2Bx+D7b6paWjGexvzsGx7oVZrSZbypLFxWtralymcZEqlJ7/agz2FNTp29ZIZKfjZxIQu95UyFlsypG+tz0Fueb3edsakBFx4bDJ8vb07PSnw4Kc7NaCPDfHDvT8bi5gQHnwPtnd+zMV/fzqoJzseP38yAow9Szq4YnY7wOCD1KhAzcwPjwrU4PqTNkF2XKgfTh4Xr5UdUsXo7cCeAdUNJvzxk53ILavTE0v3nzHOo7fn/gbbMt44IMDzKwCo9+rr63HgwAHPCrZvvfVWPP300/D19cWJJ56I4OBgrFixAhUVFdq17ssvv+zyA+FuwbYcDEhDCxlrI9+x180biRNG9T1AlunBnluZiZ9ybBkEaSwjwTvHcRMNjMZmMwze3vAepM8Yg+3Bx2C7d5rNFizbWYj3fspDbaOtZHtqcjgunZna73JWk9mCf32bhZW7i/XnGcMjMS01AonhAbpIYHaosgFf7ynCqj3FqKgz6eOko/kN89OOOva3uLoBD36yU7OqEuz97mfjPD4j6ErkhMed721Bs8WKWxdmYOZI9/y+21dUjUc+362NyzojQfY5U5MwJz16QI/P5ATVHz/ZoV3M5QTSfaeP61fG3JX1dd8oCb3MzEwkJydrvEHUWZf13NxcpKWlwWg0un+w/cEHH+Ccc87RDX7VqlWYNm1a69xtEnhv3boVd9xxBx5//PF+Bdu7CqqwYncRyutMqG9qRp3OY22G/OJp0UHaKGV0fChGxgTB4DMwcxfKQcOzK/Zi/YFyLWO7YUEaZqVFO2SqCDkrLAc69inCZBx3x6YaRNS7z9WWvEpszCnXJkulNU3alEYOpuSzdcbkYTh5XFyPh370FYPtwcdgu2fk0EFKxV//PkdnzBCSrbtsZopDG1zJ63yxvVBLwy0djlbCAwyoqLcF2EI6jM/NiNGMdk+bVUlm+0+f2gIUCYr+cOYETj82COTv+tBnu7Qx3qSkMNy1eIxbd4eXpmcFFQ04UFqLAyW12ndAjvsWjo0b8CC74/b8x4936GcyPtQf950xTqfV8zR93TfKdrd3715EREQgJibG4etF7q+goAC1tbUabDvqO8mpwfaMGTOwfv16PPjgg7jnnnva3bdmzRrMnTsXfn5+KCws1KC6N8G2/Fqb8yrwwcZ87dbYE1KOLWOfxw8Lw4TEUKTHBMPXAcG3TA3xyroDeunr7YVbTsrQJhiOJOO4n/96nzbdSAjzx29O7ltTGaKhrL7JrNOvfLH9kA7R6E6ovy/OnJyIk8bFws93YIJuBtueG2zLCR3pki2VTnIcPiw8AMPCAvQyJsTPJSuUpFRVp+2SDuMHKzUjLCQ4vXB6EhaMih2wqo89hdX6Xsl4axlGZQ+y5dUkWFswOhbHpEb0aZ8tGcH7PtyO4ppGnc5JSsoH6jNNtgohOTb7YNNBPe569LzJrChwIGmc9vuPduj2LBUgvzt9nMc1AezPvjEvL0/LyaVM2MeHn3NqX0Kek5OD8PBwxMXFwVGcFmwfPHgQSUlJen3//v260XeUkpKiqfw33ngDF198cY+D7U255Xhr/eGOphLgzhsVoxls6XwqDVdkkbOOMh5MgnGZekHmAG3Lz9db/82I6GAkRQToWXsJZHua/ZYvPOkevmZfSevz3b5o1IBNayFnVB//Yrdm4IKMPprhdocpNIicTT77cuAn3WLrTbZSWBl/NzcjWj/3MgYuOthPMwQybEMqSeyBhmTXrpk7Ug/0HY3BtucF2xLYScmz9O2wb0MdSQAyY0QUThobi9FxIQ45uy67+vzKBi15lRA1xM9Xp72SSo0gP199TRnbLPtLCZirGkw6/lOm65JL2Z9Kxq7tAYP8GxlHLSedBnusrYwRz6+s18+mI0plJYi/f+k2LYWfnhqB204aNWjDRYYK6VkjJzNlKlPJwIoLpyfjnKmJzl41j1NU1YDff7xD32fZh/3uZ2MdOne9s/Vn3yil5DImV4avRkZGalLPnasqqP/7RrPZjOrqao0rZXuQYQaOPBHjtGD7448/xhlnnKEbemlp5wc35557Lt5//3385je/waOPPtqjYHttZgn+umKfHhBIcCsNWqTD5dE6jcrbIGO/ZN7DbfmVeva+uk3nSDvZ98oZ2KSIQFsA3nIpZ8FlDHVtY7NONSJzKH66tQBNZtv0DnLQLvNiD3THUzmQe2LZHm3WIeQs/YljYjFrZNSAl7wSdUdObslBe1ZprZZlS3Dq7C76cvC3fFcR3tqQ0zreVLoTS/+DeRkxXX5mpGTwmz0l+O/GPJTUNGnQce/PxmFUnGN7RzDYHjyyD5ADU/3ebrZohlSyyxJ8SqdhCeh6OiVPZ/YWVuPTbQVYn1WuDcTsJ3TmZERrAzEJHPMr6rUU1b7fELJ/OamlFFWC4t4orGrAxhyZx7cKOzs5odwV2c91LNluuz4yXEkW6aTsSfsVGXL20Gc7YTJb9Tvgylmp/T4Il++98pbAUrYfOVaQS3laOV6QkwbVjc16ckO2v6KqRhRVN+hlSW0jwgOM+p7blkCMiA5CXKi/S31upAu2HHvIMVNVownV9c36e8sxmGwffgYfreT4bGtBa/O66GCjBtqyXTPQGRgFlfX4w0c7tApEtpt7Thvb6+8QV9XffWNdXZ0OWZVyYSIhDblDQkIQHR3t8IoHpwXbzz77LG6++WZMmTIFGzdu7PQxt9xyC5555hmcf/752rH8aMG2dCKVzK4cyMh8hZfOTOnzmTzZMUhgsLOgGrnldcjTpV7HeveGZCUun5U6qEGFfeqTlbuK2x3UzU6P1nHpcuAo2XlfH9tBpFzKz/brtkt5jO26HHD2ZGcoO1c5WJAxrhKAyPWmZrM2htPFajsBMmNEJEZGB3EHOwTINvHuj3k6pCOvrL51e7STRkrSrdgZQXdmcQ3+uSYL+0tsO9vUyEBcPCNF5zvtaZdYaQ711PK9OnZVysr/eNYExDrwQJjBtuO/GyWDKdlaXUprW67X6/d9Vw2OhGwS0nRIyjKl1FuCH/t1+1zRHcn33voDZRrA20+AiozYYCwcG4uZI448CSr7nqySWizfWYi1maWt8/HKd7FME3nSuLijfl6k5FqmGpIptDpmouXfynPJ7yqLBEj2ao6O5PeVuahlkeyYnEzy9CmypLLhmRV79bocQ5w+aViP/628n2v2lmBfcQ1Kqhu1jFcCbUcfZB03MhIXH5vi0O+a3pLkhFTtSWm/fcx+TwT5+eDsKYnalbs/J6+oZ+TYVcZwS0d0Sb7IPNzu1vF9IPeNzc3NutDQ5u3trcH2QMUlTgu2H3roIR2nPXv2bB2f3Rm5Xx538skn44svvugy2H5/9WYcavDBE1/naEZAsrjSgMyR0yoIeaukyZot+LaNG9MgvKIezWarnjGU8m25tDVqidbuqc4KKivrTFqyJc3h5MxzfxhaAnLb4qUBuBxIShdR+d3NFgvqTYezMUcjgc380TGYnRatpYyeSCodJDshZ5VlrKMc1MpSZzLD6OOlGQ45+eBn8NaxmjIdiCedgJDt45mWpoB2UrIqU6LIzn5Ddjns3z4yh+550xIHPOgurm7E9vxKbM6r1D4H1pYTUTLeVLKHfRknK/Oo/uHjHVpmmxjujwfOGO+w7AGD7d5/R8vcya3BdEsgnVNquy6Znq4ytkI+fhEBBt0+7d9tciljTBu6+X6LCDTYgm6DD0wWq55kkkUCrrKWDtmSIZdgWaZ6lKmBekIynxLQSPWF7HPs5DMk26tkq2SdvSGl35LJasCnWw+161Mic/lKD5Ix8aE653Rnw6AkwDe3/r4WvZSTAJ5wUN4XH28pwBs/5LSeELzsuFQdQtZlw6WiGh0WsG5/qWbFO5J9phyP2E+ctCXfP7IPlGMG2fYkgJaTHHIpJfISrMvfXo4z5HhDquasLc+5eHw8zpoyrMuTPQNxskqOKVbLCYU2J49kXeQkjCQ35KSjXEog3Wgyo6HZopfyu4+KC9aTF2zgOrjk+0+muZOTQZIAks7vYYF9S0TJ9i7HNHLyXLbZ4dE9+y5zNO4byVX05LjdI4Jt38hkxF/2KHwCQjApMQS3nzjSIY3NekreQlcOkuRAauehGnybWYbKhmbNxskBgW2xXZcDLLmUkxX2A8y+kCDSNobOiKgggwaU8qeQDuwSyBRWN+LH7Eo9IBUGGU+fEYVLj01067PcEnB9l1WB3YU1+jseqmpsnVuzp4ZHBeCsSfE4JqXnmVVX3uZeWJONNZnlGmQsmZWM8Qkhuk3YPyuSDflwcyG+3V/WGgAdNyIcPz8mUUsMe0u22R0F1diYW6mBkZYAy4khLy80NJv1M1BUbSvntJs9MgIXT09EeB8PPOykiuP+T/boybgJw0Lw65PS9Pfur4EYB+7utOtvZaOWo0oQIsG0BCK55Q3ILavXktzuBBi8W4YAHV6SIvyREiFZan9sO1jVxQGmjBFu0K7Vcnmw5brc3h0ZG33SmGgsHB3d5+1MXn9PUS2W7y7BDwcqjvr9LNu+bNs/mxCr2Xfq/fv9weZDukjsLO/n4nEx+v0s/V4kaNlXXKt/k025lcgpP5zZTY7wx3HDI7SzeUyw9HowagAq33vyvPb9rJzckJPzvT1WyS6rwxvrD2J7gS3Ylec+f2oC5mdEDdgYcwmyV+4pwUdbC1u3d/kanzgsBMePjMT0lDCPGk7gibJK6vDnL/bpyX4fLznBHabbzKTE0G5PMks15/YC6WtUo9+58j1r/46VbUCOt6cmH9nAeKBx30iuoifztXtEGfn4u95DjdUP6TFBuPu0sfzSd1CwJEG3PUNzODC3B+dWDSYkmNFLb28E+vnogeXRTjzIGLVvM0vw9Z5iZLc0sZPy9jtOGoUINytRlNLTr3YVaelgZ6WYciBkO+NvO9sv749ki+Q9lGyZnO1vaDJjy8HK1qyHHPxLwxipinDHBj3ylfLy2gNYtrNIx37eepTu+1KO+P6mg/oe2jM2p05IwFmThx01syaB1478KnyfVaYZ9O7KgIWsj23GgVBtgjTSgZl0aR4lDWnk77hwTCyunj283yfhhurZe3tzLvl+sDfokiBDgmkpA5dApTta/hwViJQIWwm0Xm8ph5bgp7u/S28bpEn2WdZJAnA5kSnBk5x0lO9EyVqOjg9x6IlEeW9W7ynRjLds7/JdLXtxuZSs9ey0KM14utt3qSuSv+u/v8vWShghHZ2D/XxwsKJ92bR8Z0lFnfRHkSECA33yXb5jf8qp0Oy7fdYE2W9IBl7G0jvyJLI0jVy6Jb91DnM5mS7VGVKl0dPp1cg17C+uwcvrsttVJUhVzrSUCL2UYxSpOpATSjK8Sqa/3FtUfUQ1kGze0mdCqoikOk+6ncvQwME0VPeN5HpcOrP90Ucf4cwzz0RUVJQ2KeiuQdqvf/1rPPbYY10G28m3vo3U+Cjcd8Z4lie5mS15FXh2xT49aJQv+ztOHu30plk9baQjnebblmvKnJbHp0chKTwA8WEBmtnoaXmfHEB/tvWQTjllD9rloO2GBeku1QznaOTrRN6XpZvzdUoeWX/pFdDTbvqvrcvWJoX2A1uZzkdOxMiOXE5ayJealOTLwa90Bd+SW6ENCdue3JCeADEh/i3DHGwZJKkUkPFqY+NDB7Q0VsZu/+XL3XrS4PxjknDeNNuMC33lqQcU8jeRkm7buOm2Jd+2xX5g3xUJXu3Bc9slNUoaVtqGKfQV59mmjt9pG3Mr9Lup7dhkKSuXMeyyyHeOM4495OTOsp2FOjuCvcHjtJRwXDIztVcVDfI7ygl0GeYkgdjuQ1W6b5PeAfZAS4Lss6cmYv6omEGtHCTHk5OXkuz4Zm9xp42AOxoW5o8JiWG6L7Y1BQ7UYSuPfL5bpwGUGTn+ePYEnbFjsHjqvpE8k9OCbZnnTlqrO2Lqr+N+/xHuPfsYj2/c4qmkY+5jX+zWLII07vnlCWku+0UqZ/plWrnPtx9qzZROHx6p4yclW9rf8m856fD5tkPaUEmCbsmMLZk9HHMzYuAOJMj+T8tYx2vmjMDCsb2bp1C+jn7MKcfr3+Uc0XRHqgPkgE8ynG2/tSTAPnZ4JI4bGaXdkZ09P7H8/V5Zd6BPDZY6ctXPQU+35Zx2mena1kZkMva0s7GtbUkGWppypbZp0CVjneW6ZK4HquqDwTZ1FdhKnwmpHpAToTK3uKuQarH3NuZh2fZCbUIpHw0JimS+dvmsyMlHaUxma2DapNOSltQ2aVWGjqs2WY5oXmknJ43lO4xBtmdu01Ihsb+kprUrvpzMrmk0Iy7ED5OTwzE5KUy3n6760jzw0Q79TpehOY7sV+LJ+0YaepwWbIsZM2Zg/fr1ePDBB3V8dlsyjnvu3Lk631lhYaEG1V0F21/8tB8hoaGDuObkaPKlLRlu6SgvpCv0mZP7HqQMVDb776szW5vNLRgdg/OPSR6QkzzSyOu5lftaM+dSGnr1nBGD1ginLyQjIvPUSiakv0GmHARImeyuQ9Vani1jc9seDErANTUlXMvf0mOCXa7c/v2NB/H2hly9fvXsEVg0rncnHdzhgEKmTSusbtCA2lbibQuspfRbrpe2THfUFSm9lYAguU1W2n5dFmdNUcNgm9yVTB33+vc5WvXTF/ItmhQZqE20xsSH6BCIwcxWkvuREze/+3Cb9iuRhMNdi8cMykkZV943ErlUsP3BBx/gnHPOQXBwMFatWoVp06bp7TLv9oIFC7B161bccccdePzxxzv9953Ns03uSw7eZQzaJ1sL9OfLZqbiZ5MSXCabLSXe8mGR4PrauSP1rO9Al9p+sOkg/vtTngawMcF+uG3RKO1A7Gqkgc7/vr9FG0bJWL6bTsxw+PPLLAByEkLKwd3hAPDN9Tn4cFO+Xr/+hDTMGxXjdgcU9U3m9iXerVNl1WmzHPm7dEeGhqS0ZKNTIgOQGhlkC6ijAnXYhbOrEDrDYJvcnfTBkHnb5fvSvsgJbdl3yXzxtgamfloVJD1udC7slpkxpNcAUW/IELDff7RdKyROGhuL/5kzcsBf09n7RiK3CbbbNkGT+c0WLlyIoKAgLF++HBUVFdqpfNmyZV12emOw7Zlk/JnMzSyuOn44Thkf71LZbGlCM5gZZpkz968r9umcrVJmf/38NC2ZdiWvfZetpe8yduux8yd77HRuvSFfra+sy9aTNDK64Ib5PR+/PlgHFLKOciCe00kzMrku93VHmiMmRgQcLvNuU/ItAbU00XE3DLaJiHpnU265juEW/3vqGExKGthkBINtcidOD7bF22+/jeeeew6bNm2CyWRCWloaLrvsMtx2220wGrsu0WWw7Zlkk3x7Q55mdfs69re/pFO4js3edjib/Yu5I3U+aGeQsXXPrtjb2hX33GmJ2nzLFaYIkxMSMs+0vE+/OWW0lnaTjXSI/r/V+7UZjZiUGIaLjk3ucRd0RxxQSGWGjJG2NyNrW/ItS3fzR9vHykuJd2tWuqXkWy6lSZSnjeNksE1E1Hv/+jYLX+4o1H4bctJ9IGcGYrBN7sQlgu2+YrDtuWSzlJLyj7fYSsqvmzcS80fHDspr7z5Ujb+vymxt0CWNYS6fNbjZ7K7K7F//IUczyEI64Ep5sjOnupNA7rfvbUFRdaNm/a+dl+a0dXH14RHSVM8+ZdVxIyNx4THJSDhKx+CeHFDIZ0XGR9vHSh8u+bZddmw015FUcg8Lt2WnO06TJQF2WD/nIHc3DLaJiPp2PPCbdzdrE76Tx8VhyewjGx87CoNtcies9SSXJFM8XTIjRacjkezyC6v3w8/XZ0C/YCUokvmepYxdTkHZstkjMCXZNTK10gTs8uNSdezri99k4YesMi3zve/0cU4LuKUZjwTaciZbyuup87+bvDdy8CHDI6Tx23f7y/TvJ13UTxgVoyV33Y1flkqLg+UtU2V1Ml1WXZvpzzoTZPTRsdNa5h3VvuRbAm1HzgNNRERDjxyHyAn3hz7dqRlumXt+TAKbFxMxs00uTTbPl9ZkYfmuIg1G7jxl9ICMBZKOmn9duU+7X4u56dG48vjhTuuI3JNx3DKfc1VDs3Yql/ms5QTFYM+R/ufPdun1e04bq/Nw0tFJcCxDFNp2DA4PNGBeRoxOs1JRb0JRVaNOidfQbEZuWb02O+rum1r+9Amh/p129pbpsqRR2WBvH+6KmW0ior6T5MjK3UXaBPPh8yZqosTRmNkmd8Jgm1yeZJwlEF63v1Q7pt77s7FIj3Xc33vDgTL8Y/V+nRfY3+CtUzW5w7zWMlb6j5/s0E7lS44fjpMHsZFcZb1Jy8flcqDLxTxVdmktVu0pxjd7S3TbOxqZc71jmbf9emJ4gFOHE3gSBttERH0nne9/8+4Wndf99EkJuHSm46veGGyTO2GwTW5B5l1+7Ivd2HKwEsF+vrj/jHFIigjs13NKCbZMz7S25eBaptS6+cQMxIf5w13I+G3pBC5Z//tPH4eMuJBBafr16Oe7tFlbUkQA/nT2RJYh93Pb/imnAl/vLtLpzWRKnthQP8SF+mN2elRLYB2kpfrMTg88BttERP3zU3Y5Hvtyt1Zd3X2q4yvfGGyTO2GwTW7VfONPn+7EvqIaHU/9wBnjERPi16e5gz/cfFADVZPZCglfTpuYgJ8fm+x2nZXl4/v08r34PqtM35M/nzMRoQGGQQnwDT5eGmhLuTINDB5QDD4G20RE/ff81/u0cksqEv/31LEYHe+443TuG8mduFdkQUOalMnKmG0pmZXypN99uE3nMDaZu5+6yB6UFlTW4/NtBbj17U34cFO+BtrjEkLxp3MmagMrdwu0hWQ6r503EsPC/PU9eXblPi27HyhZJbXaWVtcftxwBtpERER0hGvmjMTExDA0NlvwyOe7kFlc4+xVInIKZrbJ7UhQ+adPdiC/0jalUVSQEedOS8K8UdHw9fbWMueKOpOWieeU1WJnQTV2HqrS2+ykccelx6XgmJQIjyjNlSmf5OSD7NTOnpKoczkPRGXB//53q04ldezwCNx20iiPeO9cGc/eDz5mtomIHENm0pBAW47Dgvx88LufjdOmnf3FfSO5Ewbb5LbjXFfuLsb7G/NQ3hJEy5hWo483imsaNWvdka+3F9Jjg3HcyCgsHBPrlpns7ny7r0QbyYnfnDwa01IdO2WZzD0uDb2kXP2Rcych2N81O7V7Eh5QDD4G20REjj1RL9OB7S2qQYi/r05X2t+eO9w3kjthsE1uranZgq92FuLDzfmoqj+cuZYpi6XRlDQ7k3FCYxNCkR4T7PGNvF5ee0BL62VeZSmPlyZbjrBiVxH+75v92uxEzkzL+0kDjwcUg4/BNhGR4zuUP/jJTh2KJrO+zEmPxklj4/qc5ea+kdwJg23ymDOnWw9W6vRIsSF+iAw2akn5UMz4/+HjHXoGWeZa/sOZE/p9gmFfUTV+/9EONFusuHB6Ms6Zmuiw9aXu8YBi8DHYJiJyvJqGZjzyxS5tcmuXERuMhWNjNdMt1Ycys4ocu0nJeYh/181euW8kd8Jgm8jDlNY04u73t6KqoRnzR8XguhPS+vxcFXVNuOeDbTpOfnpqBG5bNAreHKc9aHhAMfgYbBMRDQwJOXYUVGlF4vqscpi7CUEmJ4Xh5HHxmJIcDm8pV2yD+0ZyJxx0SeRhooL9cNOJGXjos534ek+xzr194pjYXj9Ps8Wi04pJoD0s3B/Xz09joE1ERER9Ik1Vxw8L00VO5ssxipzglDLzZrNVK+jMFivqTWZszqvURaoVF46Nw4LRMd1mu4lcFTPbRB7qg00H8db6XJ0PWzqHT03pXcO0V9YdwOfbDmlp/h/PnqBTrtHg4tn7wcfMNhGRcxVWNWDZjkJ8vacItY1mvU2OZR4+dxKGhQdw30huZegNaiUaIs6cPExLv6Uz+2Nf7MbSzflawtUTy3cVaqAtfjU/jYE2ERERDQpp7nrZcal47pJpuHbeSIyIDtLbEsIc0/SVaDCxjJzIQ0nJ9y0LM7RD+fJdRfjPDznIKa3FtfPSumyaJt3d//19tp5RFtIMbfrwyEFecyIiIhrq/Hx9sGB0rPafqWls1jJ0InfDYJvIg8lc4tfMHamdyV9Zm41vM0uRX9mgZeUxIX5HlG3JGG2ZmkOcNWUYzj8myUlrTkRERGQb683x2uSuGGwTDQGLxsVrKfiTX9mC6Zvf3IhhYf5Iiw3WqTdkqo3XvsvWpiTBfr64YUG6dgAlIiIiIqK+YbBNNESMGxaGh86ZgL+u3Ic9hTWa4Zblm70lrY8ZHReCm05M147mRERERETUdwy2iYaQmBB//P7MCahqMCGzqAb7WpZDVQ04Pi0K5x2TpFluIiIiIiLqHwbbRENQqL9BpwLr7XRgRERERETUM0xhERERERERETmYW2e27XMG19ZUO3tViIgcrqqK3VcHW2019ydERK6M+0ZyJSEhId1OS+dltUesbigvLw/JycnOXg0iIiIiIiIaYiorKxEaGuqZwbbFYkF+fv5RzygQEREREREROZJHZ7aJiIiIiIiIXBEbpBERERERERE5GINtIiIiIiIiIgdjsE1ERERERETkYAy2iYiIiIiIiByMwTYRERERERGRgzHYJiIiIiIiInIwBttEREREREREDsZgm4iIiIiIiMjBGGwTERERERERORiDbSIiIiIiIiIHY7BNRERERERE5GrBtslkwvLly/Gb3/wGxx57LMLDw2EwGBAfH48zzzwTn3zySaf/7oEHHoCXl1e3y65du/q7ekRERERERESDzre/T7Bq1SosWrRIr0uAPWfOHAQFBWHHjh346KOPdLn22mvx97//XQPojiZPnowpU6Z0+txhYWHdvrbVakV1dTVCQkI6fW4iIiIiIiIitwy2vb29cd555+GWW27B3Llz29331ltv4dJLL8ULL7yA2bNn44orrjji35999tma5e4LCbQlIF+2MQtBISF9/h3ItchJFEtzE7x9jTyJQkN6O5+VFjXo6zXUrcssdfYqeBR+n9NQwO18cHHf6LztvKGhAf7+/tzOB7OM/MQTT8S77757RKAtLrroIlx11VV6/dVXX+3vSxERERERERG5hQFvkDZ16lS9zM3NHeiXIiIiIiIiIvKMMvKj2bt3r14mJCR0ev9PP/2Eu+66C2VlZVoSLsH5GWecoeOwiTrT1GzBy2uzEGDwwQXTk+Fv8HH2KhEREREREQ1esH3o0CG8/PLLel3GdXfG3kStLQm6n3nmmU7HeNPQJuNFXlyzH9/sLdGff8wpxw3z05ERx5MzREREREQ0BILt5uZmXHbZZaisrMTEiRNx3XXXtbs/LS0NDz30EE499VSkpqbqbdLB/OGHH8bHH3+MK6+8Ej4+Ptpg7Whqqqs0CDMYjTD6+Q3Ur0SDRP6W9qWjz7Yd0kDb2wsIDzCgsKoRD3y0HedMTcTZUxLhI3cQufl23vYxNLj4ng/+dk7k7ridDy6+z87B7fxIPWkU52UdoHfsmmuuwUsvvYSoqCisXbsWo0aN6vG/vfnmm/Hss88iJiYGeXl5MBqNnT6uqqqq3fRgS264HVffeIdD1p+cRz/IZhO8fAztNuLtBdV45Mt9sFiBy45NxNz0SLzyfR7W7i/X+zNignDj/OGICup8eyFyh+28rWNSIwZ9vYa6H7Nt3yc0eNs5kbvjdj64uG90Hns3crIJCAiAU4JtmQZMysAjIiKwfPny1iZpPSXjt2NjY2E2m7F69epOO523DbbfX70ZQcEhzGx78BQaxdWNuOeDbahpbMac9Ghcf8LI1vu+3VeCf357APUmM4ZHBeL3Z46HwWfAe/8R9Qun/nJNnPrLsTglEg0F3M4HF/eNzsGpv47Uk/fB4WXkd9xxhwba4eHh+PLLL3sdaIvIyEgNtgsKCjSzfTTBIaGcZ9sDN1770thsxhNf7dFAe0R0EH4xd6TO7243JyNGx2zf+8E2HCitw5vrc3HFrOHOXH2iXm/nXd1Pg4vv+eBv50SegNv54OF77DzcznvPoem/O++8E0888YRmmyXQnj59ep+eRzLaMtZbsCs5vbYuG9mldQj198Udi0bB6HvkZhsX6o/rT0hrHdf9Uw5LQYmIiIiIyAOCbZm+67HHHtNAe9myZTj22GP7/FxLly5FXV2dnjXpa8BOnqG2sRmr9xbr9RtPzEBUcNfDBKalRmDxhHi9/vdVmSirbRq09SQiIiIiInJ4Gfm9996LRx55pLV0/GiBdk5Ojo7FPv/8848YZP/BBx9oczUhncjj423BEw1N32eVwWS2IjE8ABOGhR718ZfMSMHOgirNhD//9T7cfepYeLNDORERERG1YTKZtJqWej5mu7GxUa97Uhm5t7c3DIaBa27Y72BbstB/+tOf9Hp6ejqee+65Th8XHR2Nxx9/vLUB2uWXX47rr79ex3QnJiaivr5ep/7au3evPmbBggX429/+1t/VIzf3TUtWe15GdI8+BNIY7eYTM3D3+1uxPb8KSzfn4+ypiYOwpkRERETk6qTBcklJSWvgSL0LuD0p0LaT6aYDAwO1Z1hXs2A5LdiWwNluw4YNunRG5tK2B9vJycn47W9/i/Xr12Pfvn346aef0NTUpAH56aefjksuuQQXXXRRuyZYNPQUVjVg16FqeLU0QeupYeEBWDJ7OP6+aj/e+TFXp4hIjgwc0HUlIiIiItcPtA8ePIjg4GCNOwYyo+lp7HNse1KDNKvVqtUNkvSVfmEHDhxAUlKSBt6OMmDzbA8G+9RfyzZmsRu5B06h8f6WIrz300FMTAzD3aeN7fVzPLFsDzZkl2NuejR+tSB9wNaXqC849Zdr4tRfjsUpkWgo4HY+uPqzb9y/f78G2BJQ8W/VO54YbLclQXd2djZ8fX2RkpICR2HqmFySfJi/2Vui1+dmRPf638uXgL18fG1mKUprWCpERERENJTHaEvpuCTqPDFYpP6Xksv007W1tWhuboajMNgml7S3qBZF1Y3w8/XGscMj+/QcaTHBGJcQCrPVik+3HXL4OhIRERGRe7A3Q5PMNlFn/Pxssx4x2CaP902mrRfAzBGR8Df49Pl5zpicoJcrdhXqNGJERERENHQxq02DuW0w2CaX09RswfdZFXp93qieN0brzOSkcCRHBKDBZMFXOwsdtIZERERERETdY7BNLuennHLUmcyICjJibMLR59Y+2hmq0ycN0+ufbzsEk9nioLUkIiIiIiLqGoNtcjn2xmhz0qPh7YByjuPTohAZZERFvQlrWp6biIiIiIhoIDHYJpdSUdeEzXm2EvI5fehC3hlfH2+cNsE2dvvjLfmwuO9sd0REREREdBSuMkUZg21yKd/uK4XFCqRFByIxPMBhz3vimFgEGn2QX9mgZepEREREREQDicE2udTc2tI1XMzLiHLocwcYfXDS2Di9vnRTvr4WERERERHRQGGwTS5j16FqzTzL3NrHj4xw+PMvnhAPo4839hbVYEM2s9tERERERDRwGGyTy1jeMjWXNDQL6Mfc2l2JCDTitIm2sdtvfJ+DZgs7kxMRERE5ktli1SF7r647gL+u2Is/f7oTd7+/FTe+8RPueGcTnlmxFx9tzsfWg5WobjA5e3WpRWZmJnx8fBAREYG6urouHzdhwgQdC/3pp5/2+LkrKioQEBCgz3/w4MEuH3f++efrcz/99NNH3Pfuu+9i8eLFiImJgdFoRGJiIi677DLs2LEDrszX2StAJOTL9vusMr2+sKXceyCcOXkYVuwuwqGqBizfWYRTxscP2GsRERERDRUFFfX4ek8xVu8tRkVd10F0fkUD1mWWtv4cH+qP0fEhGBUXopfDwvxdorHVUJOWloaf/exn+Oijj/D666/jF7/4xRGPWblypQa38thTTz21x88dHh6Oc845B//5z3/w2muv4a677jriMaWlpfraEkhLEG3X3NyMSy+9FG+//Tb8/PxwzDHHaKC9Z88eXc///ve/ukgg7ooYbJNLWL2nBM0WK0ZEB2FkdBAszU0D8joydvv8aYn457cH8N5PeZibEY1AIz8GRERERH1RXteEv67Yhx0FVa23hfj74riRUYgL8dfr9qWm0YwDpbU4UFKrl4VVjZoAkWXVnmL9t9HBRvz65NFIjQoatN9BevnUm8xwV1IR6ogTFDfffLMGvM8991ynwfbzzz+vl7/61a96/XpXX321BtuvvPJKp8G2BM5NTU0477zzEBV1uHfT/fffr4H2zJkz9d+PGDGiXbb75z//OS655BLs379fg3pXwyiDXKoxmnQNH2gLxsTi8+2H9Mzqh5vycfGMlAF/TSIiIiJP02y24Kmv9mBPYQ0k9pqSFI75o2MxLSVcp17tzJTkwwFRTWMz9hZWY09htfbuySyuQUlNE55evhcPnTMR/gMwrLAzEmiPu+8LuKsdfzjFIcmjk046CePHj8fmzZuxZs0azJkzp/W+vLw8LF26FIGBgRo499bChQuRmpqKXbt2Yd26dZg1a1a7+//1r3/p5ZIlS1pvKysrw5NPPgl/f3+89957mtHuWHZ+3XXX6UmAf//737jxxhvhajhmm5xuZ5vGaLPTHDO3dnd8vb1xyYxUvf7ZtgKU1DQO+GsSEREReZp/f5+jgbZMr/rYeZNx5+IxmDEisstAu6NgP19MTYnARcem4P4zxuO5S6YhMsiIgsoGvLz2wICvP3We3RZ//etf293+j3/8Q0u6JYvclwyyl5cXrrzySr3+8ssvt7tv06ZNuiQkJLQrB5ey9fr6esyePfuIQNtu/vz5erl27Vq4Ima2yelWtDRGm50erWXegzEtl5xxHZcQqiVPb6/Pxa8WpA/4axIRERF5im/2FuOL7Yf0+g3z05EYEdDv5wzxN+CGBel48JMdWlY+MTFMjw8HowxbssPuypGNhWW8tJR5yzjogoICDYClvPvFF1/U+/uTPV6yZAn++Mc/4q233sJTTz2lTdPaZrWvuOIKbaJmJ6XhYvny5UctWy8utg1DcDUMtsmpqto2RhuEEnI7+cBeOjMF93ywDd/sK8EpE+KRFhM8aK9PRERE5K6yS2vx4jdZev3cqYmYluq4KVslGXLO1ET896eDeGlNFtJjgxEX6o+BPi5kDx8bKROX8dqPPvooXnjhBR0zLSXchYWFmDt3LiZNmtTn5x4+fDgWLFiAFStW4P3339csuclkwhtvvHFECbmwtMwclJ6ertnt7owZMwauiFsVOdU3bRujDXKwK68nZ0u/3Vei441+f+YELV0iIiLPGU/aYLIg2J+HO0SOIuOsn1i2B01mCyYlheG8aUkOf41zpyZh+8Eq7C6sxrMr9uKBM8frMEAaHDfccAP+8pe/aLB99913t5aUS2O0/lqyZIkG25LNlmBbGrKVlJTg+OOPx+jRo9s9Njk5WS/l9o6l5+6CW60LKattwvJdhdhwoAz5FfUePw+0pU1jtMHMard1xaxUnXJCmnE8+vku1DU1O2U9iIjIsaTR0h3vbMYvX/8RH2w6CItl4IcoEXk6Ger3j1WZKKpuREywH25akAFvb8dP0+Xj7aXl5EFGH2QW1+KdDXkOfw3qWkpKCs4++2zk5+fjvvvu0/HQw4YNw7nnntvv5z7vvPMQFhamAXdubm6njdHaNlWTqcC+/vprFBUVwR0x2HYBxdWNWiZzy5sbtSTnL8v26AHCVf9aj1+/sxl/X5WJUg9s4rV8Z6E2RpNxJscPQmO0zoT6G3DXqWMQFmBAdlkdnly2RzMhRETkvsHA59sKcP/S7RoQmC1WvLU+F7//eDsKqxqcvXpEbm1TbgU2ZJfD19sLty0aNaBVIzEhfvjFvJF6fenmfC1dp8Fzyy236OXDDz+sl9deey18ffv/9w4ICNDpuqRE/JFHHsHnn3+upesXXXTREY+Ni4vDTTfdhNraWpxxxhnYunXrEY9pbGzULunS5dwVMdh2Itnpv7A6E7e9tQlf7SxsLaeWRTpzywHCwYp6bRDxm3e3aHAq2WBPyeL/54dcvX7h9CRtjOYsMg7ot4vHwN/gjW35VXpyw1PeZyKioaS2sRlPfbUXr6zL1n2odEW+Zs4IPakrHZN/+55tXzoYjTiJPI18pl7/PkevL54Qr8erA23miCicNiEe184diZTIwAF/PTpMxmdPnTpVrxsMBg22HWVJSxZb5vOWDucyhVdISEinj5VgX8rNf/jhB0yZMgXTpk3Tx0vALlOTyZzcZ511Fg4ccM3u9RzE5CTrMkvwt1WZMJltO/wJw0JxzrQkbQohJNgrr21CbnmdNojYW1SDF9dkYW1mKa6dN3LAG0UMtJfXZumchtL04uRx8c5eHd1h3HbSKDz6+W58m1mKiCAjLp1pmx6MiIhcnwy/euTzXZrNlhLUy2am4pTxcdr4aFJSuJ5IlRkoZF+6+1A1rp+fdtTutkR02MrdRZoEkum6zp7S+TRMA+HyWcMH7bWovZNP/v/2zgQ8qvJsw2/2HZKQhEA2SAgQ9n2RRRZREAQRtLXa0hatrb8VrdSltIrV6u9SrVq6+BerrVpbVGipgCCKgMgmCCRsCSQkgewL2ff81/NOJiYhCVlmz3Nf1zCTmTPDmTPf+c73bs97vRw9elSN29DQUJM5KidPnqz9vBMSEtpMITeCaPo777yjKulQRD9w4IDEx8eLj4+PKqUj4r148WKZOXOm2CI0ti0MBunmY5fkH4cMUV0Y19+aGCGD+zb35jg7OUkfXw+9jQrzl20JmfKvw2m6UHj4/eOyfHy4LBgZapdiEYeS8+VQSoG4ODnJ3TOizVLr0xWwGIMjA06Q/x7PkOH9e8uYiM73ESSEEGJZUP7z6s7ExjrSVdfFNuswgXTUNQvjZOuJTPnHoVTtQhEd7CPzR/Sz6n4TYi+UV9XKhq8MddMQRPPxoAnh6NTW1sp7772nj5HKbWri4+M7tf2CBQv01lFsJYPJ/iw1O0+/QW220dBeMCJU1twYd4Wh3RIYozeO7CfPLRslw/v3UvXHdw+myqMfnJD4i5fFnoAA2Rv7DK0ibhrdz+ZSgmYODtbfBby9/4LDi9QRQoglqaiulaLyapN/7sajF1V3AxG3Xy8Z3morRzixF47qJ3dOjtS/3z6QKknZJSbfF0Ickc3HL+m5C1HZ6+KsI2pLLAuUyC9cuCBTp07VG+kaNuGW2rBhg+bsHzt2TJumo5faHXfcIQ8++KDWCDjKAuOVnYkqLOHUoILdWY86UsdhnO9OzJF3D6RqKs9vtpySKdGBmi6HKLit84+DqVJYZpisl441fasIUwCP7d6kXD2+O09lyw3DrZfmDq/cqcxi2XoiQ5V1bx4bJvPiDGmRhBBiy0D9+0hqgSRlXZb0y1WSll+mkWcwpK+fXDs4WKZE9+m2ZgfmRqiNg5XTB4q/d/stHDGnY149mJwvr+w8K8/eMkqNdEK6AoIeu85kS4ivm0wf3Ff6+3uJowGR3o+OZ+jj70yKFFcXxuoclTNnzsgLL7wgmZmZKlzm7OwsL774orV3y66x+tXlgQcekFdeeUXz8efMmSO+vr4qBf/II49o37Xt27erap2915H9bmeiLjTcXZzlvjmDZOKAwC59FoysaweHyISoQE3n2X4yU/afz5ejqYU6Ac4bZruG2OmMIvnklEG2/+4ZA8Xd1TYna6RG3To+Qt74Ilne/ypdpsUEWbxHa3Vtndbnb43PkAt5ZY3P//WLFDmcUiD3zIy2C+cKIaTnGtp/2JWkGhitgd65uL31ZYpMGhAoC0b265LYUlVNnfxxF0QtRaZG91Hj/WrgGok5NCW3VI1/tDH62bzBNnvtJLZJYVmVZkd8kZTb+NzGY5kSE+wj0wYF6VgMuIrjx15AGSOyKuEkmzAgwNq7Q8xIRkaGrF+/XtttoaZ67dq12v+6JeiLvXr16g5/7l133aViZj0Rp3orJrRv2rRJli5dqgb2559/rupyxh8Qhjfk3R966KE2PSpFRUXap23H0WTxaUPBztp8eS5PXt9zTiqq67S91Orrh6gomKlAGwQYYFi0ANQYYxFxNc++NY/D7CHB8qOZMW1uiyFZV1Mlzq7uVlv8IOX/sQ+PS1pBuSpurrCgOAe85Ot2JWkGAICDZubgIAny9ZAPjqSrqB6UdVdcM0BmxgZxgWindGScT425uuFATD9Xke4BgU8YsLsTc1WbY/qgQBkQ5CsRgd4SEeCtnTf2JuZopw20fwRuLk7yiwVxMrRBJLSjvHPggmps4Pr6wvJR4ufZ8Wy45NxSefzf8bo/yA5DijkhHXEk7TiVpe3kIPTq1FCCVlBaIfGXitXxY6SXl5uE+XtKmL+3hPl7yeC+vupUsqfrNs6TNRtPCL7WU0tGmHQN21W6em2sqKiQ5ORkGThwoHh62rfQsLXWLbhh/CK9HMexo/z1r3+V73//+2LrmGOMWNXYnjRpkhw6dEiefvppWbNmTbPX9u7dq5LzHh4ekpWVpUa1PRnbiEyi5nf7ySz9O66fn/x0TqxZvJz4CT9OyJJ3D15QQ8zP01WFx7oaPTfncRga6ic/v2GIeLu72rSxDU5cvCzPbDmli8Xnlo/SC6U5wffeGp+pi0dcrAN93OX6YX1lztCQxgUksiQg4GasM0Qk577Zg2xGZK4z7XmwIIdicOPNycmuFiDdhca2bUJju3vgvP7LnmRVLca0dP+cWJkQ4dvqOMc5gBTwfx5OVyejt7uLPL5omET16ViEG4riT25OUCMAjuzxUZ2PuO04mSlvfJGi888jC4bKyLAr1xqENHXE/2bLSTmVYQhwRAf5yA+nD9R7zOfFVU6yPzlfvjiX26YeQN9eHjI1OkiuiemjDqiunme4jl4ur9Y6atx7uLrIqIjeJhXOxXy4fu95Ka2q1f3FOtYWoLFtfWPbUddrFY5kbF+8eFHCww01u+fPn2/VOxIZGSlpaWny7rvvyu23396msb3lq3Pi34ox3llwKPJKqyQ1v0zS88s0qole2DB6IOSFBUBUH2/p49P64hiTX8blCjmbVSyfnMyS87ml+vySMf01LRkGhTlBmjoiosa0Y9TDQbUcEVFrkFNcoXXq53I6dxxsxdgGL24/I19dKNCMAfTiNhdIhcQFDZEgMGNQkNw1I7rVVHtc7CFUghR3PEb9/wI7UNTF+YH6TagBQ1W/JaiZnBAVoBfRYf172aXSfmegsW2b0Nju3piG4frJqSzBkIYjEA7Bq43zyppaeXbLac3Q8vd2kydvGi4hV2lvCUPjl5viJbOoQjN8fjJrUJf3+bXPkvR31w4ZM6P12klIa+w/n6frGk83Zy3dmzu0rzq7W5vPodUD7Rc4ydMLcCuT+ItFmo5tJDzAS0b07y2xfX0lNsRX12utnScwps9mGkovcEMJBDIyWhLg7SbXxRmc9N3JcMS+v7kvRbNPAFLj4dCylaxJGtvWgca2ndVso2cbCAwMbDMNYcKECWpsY9vWjG0jSAO774ZRV1X1bouSyhr59HS2bE/IVGO7NQ4k5zc+xiTr7+UuvbxcNXWtl6ebvi8xu1hKK2sbt/PxcJF7Zw2ScZGWqW+BhxQpPhsOp2laHSZJCH1hIbJ4dJiE9va0mOL4jpNZ2uIM3lBLHwdTcsfkSBW1M97M0QoMwiMvf3JWnRLwQ6C/NxTR25rI4KxAf0sfd1etK3/vYJqMjQiw2O/blYv27rM5GrXHwri983DX2Ry9wfCeNDBQI/sdjXIRYi7g1DK3s9TegcPw7QMXDIa2iPzk2hi5JiaoQ61XEJFbfcMQ+fXmBHVyP7v1tKxdPFyvr239X3CEZjY4w7/XjTIfzLM/bihrgsGNXtzZRRXqqHbUxaS1wZhASRmcLLZivHWUbfGZen/jiH4yb1j74qmebi6qit9UGR/XQzidMdawpjAY4eWyzdBqWMd8f39Pqamt13FeWVMnFTW1jWVlLcH6yrgORbCnoKxa9Xygzo+a8VlDgmVoaK8Oz19IkU/KKVEdBJxfeNeSMWGybHyYwzvACTEXVjO24TUwRq/bIiIiotm2bZFVVClrNyfIwpH9NHLaUeGtjMJy2ZqQqYYAJjQAzzYmuvCG2jKoZueVVmq0GG1FLhWU60Uis7pCMq8MzmndGSZWGP4QK7N0VNnNxVm+MzlKxkcFNvbl/uyMwYDBwgfp7Gh/gnnXSQzpu4gkBHq7S4CPu14cukpRRbVeiD5OyJSyKoPTAbU9SCNEj1N7pF9vL1Wu3XIiQ97clyzPLB3Zbgp8R3tVns4s0t8m4VKReqixHIWBuWpurIzoYBojWm8cSM7Tz/jz7nPyq0XD9Le1FeMEafj7zuWqoBvq2oCPu4t63HFMUVJRW1+v28JDn5pXKl+ez5eDyXlSVGFwgOHc/O6UKJsW/iPmAeMCZSgYG9U1dVJdV6cLUF2E6vOGv7ENymfQZ7kaY6nhb8N7ja8ZtzN8HrapaniPfr7xtdp6jUJh/kIkSVM0K6p1zodRFxHg1Vh3jCwnPLaVc86aHLlQoEJnRqVxRIdnxHYuOoz579EFcfLEfwzR6ue2nZZfLoy7Yr7FuEBk8XRmsWpXoCypu/1+sWZAFL6vn4ds+vqSfHj0oma13XNtjF5TO+o0xZyO9GK8F3Meou8YSzAqUYY0JiJAHba4LtqD8wZGcW5JlZzPLZHzOaWarYfrFX4rtCFFyj2ykNqqk8e5g+2N78svrWo8r4xrLpxD0wcFybSYPjYv+onaZUSVsU68bljfLn0G1lhYi+GG8XEsvVASs0o0WJOSV9Z4fFoDUXAIlA0J9ZPYED8J8nVvpgqO+QyBIazBErNLNNiCGwxyOORRZoEoenl1jeQUV0pOSZXe55ZUNt4jcIRzDCCL839mD5K4TuooEEJsJI38mWee0TrtadOmaX12a+B1bHf99dfLxx9/3GYa+bKXtsnhrBp9DkIU98yMaVXAAV8VYixYGHyVWiBns76pp0GaOKKJSHlrz1jHggwTkqFOxlAvgxsuPkgDigr0tqmWCEhpx+IBHtSOgJo5pCHBEMLiEl7nQB83/X5e7q7i7eaibVqwUMgvqTJM0iWVushCurXxAtq/t6csHtNfa3w66w21pTRygAviox+e0IsQoq2r5gzq9H7hO8VfKtKIP5TjYWQ2Belj986K0fZunQEXyIc/OK7HfcXUKJO3KcMiEWUVWGSk5JbpfsOD3svTVYVfMC6QHt7UmMH2qFkrrjCck8YatfnDQzU982oOHVzosWiF4+Zow7hFe7u7p0d3u0VQT0kjVwdGq8Znw31TI7XBaFUDtnEb4/u++YxvjNwWn4n7JoZv078bjdqWhnGjEdzwOU22x/+H7aynJtJxMP7jQv10MQqjA4thWza+MeYQISutqtGoGX5PzB2IZsFghdEEzQ9cB/A9sD3O+eoaw28EsUYPV+fG8Zp5uUL+vv9C43mKawfEJDFPdnU+z7hcLms3n9T5w9/LTW4dH67zBlJ1Mde8vttQbgPH9qPzh5rcEEALp/V7U/R7w6GCNcGwfr1U1MpoIGP8pueXy7ncUq3LPZVR1Oho6AgwfkaH+8vi0f117WGL4Hdbt+ucdsVoD6cGgxkZfzhn9ffG+qy8Wg31joLPwTk0Z0iIzve2cO1vCbIeMPawroFzxtTrFpyTuNYiwIN1qIeLi97jhoBFZ9rTnc8p0e4vhy8UaNZYZ4AzYXJ0oHz/mgE22xKvO2nkKSkpEhUVZfedjqxFXV2dtgNzVMrLy1X8bcCAAR1KI+/I+e4QxjbwGjRJwpc+IlXOqHcRmRjpL17uzrpgcHV20sVnQkaJZDW5IOLwjInoJQuGhUhcqK9NTu6mIjmvTD45nasLGOPFEPdY6GLxhdSjigZDuTsM6OMlS0aFyvjI3l1edGpNSG21OLm42cxvkpRdKk9tSzTUSE8Ol+vjOha1QVRjT1KeHvuMom/GXoifuy7Sh/fz1XssUrvKJ6dz5M396boIfmbxUDVsuwOMqW0ns2VvUr46p1opC+sQMMgnDfCXqQMDJDbEp9PjAeNg28kcee/wRamtFwnt5SGrZg/U6KK9g3GEqE9ecbnkl9dJfmm15JVVqQNPjdk6Q8QfBpDRIG00lJsYwwbDt8GIbXgMQ6Crv5mtAwPLzdlZXHHvgrnd8BhzPJyc7k0e4163cXEWN30OfxueN26D5/W5xvc5aaYUnIpaJqROJVeNoOLakVZQoSmfuMecanQuGgn395TbJ4TJ6HDbiARh8a4GYU6ZJOWUaqlKYfnVF96wKXFcYIy3XCHgNRwP3ArLq3UMwghdMCxYbh4deoUzrSvzOY7ta7uSJbu4qtlxTcgoli0JBuG1B+ZEy7gI84iZwTH6ymfJUl79ze8LY3JwiI+WiqXml+v51hTs04A+3jK0r69eB+GwMDqncSxx/L9OvywnLhZreRXA4ZgV20eWjemnGWa2BK4Bbx+8qPsYGeAl0UHeehsQ6C0F5dWqun0yo1jSC9suDQKYt3E88D5cm3p7uaoTBdcHzHEHLxTK3nP5cibLoO0CpscEyg+ndjxL0RIgqLJqQ4KO97ULB8ugYB+bX7cAONLO5pTKkdTLciTtsmQWVeq818fXXSPjQT4N9w23YF93CfBys3nR1a6IIYKamhpJTU1VzSg/GxNWthcc3di+fPmyXLp0STOv0Zb6anTEaWM1Y/u1116T+++/X8aMGdNYv92SVatWyauvvirLly+XDRs2tGlsb9x9THx8/aSy3lne/SqjXU8sFlRIf0L98LhIf5tPW7IkSG/OL6uSgtKqJvfVUlhapYsD1GIjNQ7b4YKD6LdhgvZQrysENBAB6O6FxtYi20ZQc4woDhaWTywadtX2F3sTc+Wv+1IaU6i93JxlemywzIsLkfAA00UzEO15ZstpjQbDcF+zMK7Ljg4oA0NJGCUTRrAoQlQHNyykiyuQzVGj98WVNeoFx2JSDSEXZ414TxxgSFczRaoksjNe/TRJUxDxf6DvOSJnIyCiZkNZJG0B4/fDIxdVORkGNlLkS+D0svB+GH8fgxFqNFhb/O3sLG6uDQZpi7+Nxi3+Nhivhvcg2tlovDYYrYbxYDRiEZn5xjA2fGbDZzUYw3iPfk4T47jlPmIsWWI+6KhAGn5XRKGQNoxSDoxTo/E9Ory36j105DyHowTnqynTijHOtidkyccnM5vpiAD8N3Di4Hgbo2b4/xH9KqmobmZgdoSRYb20Zrqtbg1dnc9xXFD/jZTult/hxzOjtdWSOUF08VBygSE1PLPoin2AMQ0F6uhgX+2ygZZOHSkxgoGJaPi2hMxGLRgY8ohyow7YFgzMlDy0RDMYlt+/Jkqub6c2GesEpInjOgSM1x4cH2QGdLTsKru4Qj47naPin/BjwHHx4HWDbaYEDeMQoqQwsn+9ZITdrFtagnUcruO2nIHTEbojHorSVBhRMLht+beyVRzZ2K6trVVnjIuLS7tlznYT2d68ebMsXrxY+vTpo321W+OWW26RjRs3atP0F154ocOtv9BCBBcLY3QInj1cCAYG+WqNkSOlojoitnrRwn79bmeiHEzOVycD6rdbq1WDAAqEy/Y0KItjEXr98L4yY1Cw2cYeBH2M6eTfmhAhN48N69T7sc//PJymtV6YEZA69u1JEVrnhai7tX8HGA/rPkuS4+mXG59D/Te822MjA/QYIwXfFhaqLdPwf/dJYqtlHDiiiGbB4Yfx1MfHQ/+GEQrDC4YmFvFtGZ8Go7d5lLctQ9hShmpPViOHsQpRIpxDuO7gcCMlFo4hpNkimmf8DQrKqrTs5nBKvkZR4XkJ8nOXED9Pjf6F9vKSUeG9NS29M78b6ob/eyJDPjud3Wj44/yFhgicg7jBaQZBsvai4XCk4fqpxngTxwleQ7aOwelao+MMpVPt7WN353Mc100NxxX7BCfGolH9xZJgDQEHJBwqmBujg310vumuwQIH3N/3pzR27OjX21Nbn1lTNAzXgjWbTsilwgoNSqy+frBF5w6s3179NFGz8FDSAB2T4f2t244NWUQ/fe+oZgEifXzaoCC7Wbc4Kt0xtmE7oCOSr6+v2hBubtZf49gLjqhGXo9yqdpaTR9HVBvOBGiGmbLMwGrGdnp6eqMAWndbf9lin23SdWz5ogWv8JqNBgEfCN08cF1ss4UrIl2vfZqoqqDY9WXjwmXpmDCLpGQZ+8UCtP5YcU3UVevlsYjYk5QrHx5Jb6yvw0Lie1OiNEJta+MCUab95/PlUEr+FSIyOMKIgmDBiijRMCsv0GAkvPjxGRXUgcFyx5RI6d/bS48rsgWwaHeqq2brLwdr/YU65n8cTJWDKd90sAD4vWE8w2Bsq/9uSzCWYaxPGhCoRnJr46SwrEqOpBaq4X784uVGcSNsv2R0f5k4INCqKaGmms/hSEB2S2wXu47YKggEYMy9c+CClnMhoguxy+4KcXaVv+w5LztPZ6vj77llo1Sjw9JAiwQdOnA9xdC9fVKkCuBaaz3wRVKu/P6zJHWYvXb72FYzqmx53eKIdPfaCPsBgb7Kyo5rLRADRmPb0XBxcRFvb28JCQkRd3fTOjytZmyDSZMmyaFDh+Tpp5/W+uymoI57xowZ4uHhIVlZWY212U2hse2Y2PpFy5BiF691s8ZFNFQ7oeYOrzwW0xCXu8/CKp44bmj5hoU+9gwp/XAGtBZ9R4QKQkBI2TMa2cG+HrJy+kAZbYb2ZuaINMGIRRpmUnaxRmGM6foA9aS/+/YYqywUjZFLtC9Kyy/TCPzD84de0ZqQfbYdu882HENoJ4kxkFFUcUXtM6LME6MCZPyAQPF0dVaBLahYo2Ycc4xxLjGCecYgWmkQsETUDyrGiLY2/Wic90vG9NcsLluYP219PrcV4KR5YnOCCouhROaR+UMtXiaDrC0YufiVfnFjXIc7Y5gDXKNg+MMZDCZEBag6vDUEu37173h1kKEdHBzorcFxbllMdW2srq7WqCbpGBjncFDANnOkce6MzEAzZjhY1djetGmTLF26VFM5Pv/8cxk3bpw+n5eXJ7Nnz5YTJ07IQw89JC+++GKr76ex7ZjYw0ULLa2QKt6yjg8gtfmemdFttkMxN0hP/f1nidquCCmpD80bovVzWMyjLg6GKVpqQdwIoEcnogZor9Wd1m/WHjOIdGPBijp5KKLfOCJUvtuN/rtdBQbTM1tO6fGGYfTYgrhWFYdpbDu2sd3ScLhYWK6GN1SuoUQNw/lqWTToXIAsDpQhtBRjawpqhycMCFSDBCnrtoQ9zOe2AhSkf/3fk/pbQ/EabZcsVVuLzIFHPjyu1zRkBiGabAtjZ8epLPn7lxfU8QSH8KrrYpv1rTY3cOb+6t8JWo6DqHZbKf4c55aF10brgHEORXeodHOc24mx3VQEDR6FuXPnio+Pj+zcuVMKCwtVqXzHjh1t5s3T2HZM7OWihf1E/SJaguWXVkpeSZX09naT8ZEBVt9vGJtIYUZbtrZAnfBNo/rLrCEhNlfr3B2OpxdqVBmLo5duGy3Bfp1rp9bteseNJ1TFHY4OGNpttXOjsd1zjG1TGOtoiYU0Y6SNo3YUziWkmcO5Z8tCn/Yyn9vS/PX8tjPqlEE70u9OibLIcUNbq8/P5qjj5snFw21KfBJOCPRWhwMT8/qdUyDa1tcixwXp40gjnxEbJPfOat7uqykc55aF10brQGO7a1i9gd4rr7yiRvW6detk3759mtIRExMjjz76qDz44IMmz5snxFRgooGqL2621isV+/P0zSN0gYJ0ViiGGwWYQvw8ZEion/aPtaUFlalA+izSMCE89c/D6Vf0QzUnb+1LUUMbUcu1Nw23qtARcRzgDIvq4yNRXF86PKPC/eXHs2JUEBIdMEJ7e7arBm6qGml0zwDorWxr1wUovkOQFA4B9I1+c1+KOp2+NTHS7OVA+88bnG/zh5v3NyCEOC5WN7bBbbfdpjdCiOmAENcvF8ZpBAwp7aZsLWTrThCkQK7ZFK8RCaTIQyzKEqUFu87maL3j/8yKoaFNCOkS0wcFSX5JpfzjUJp8cOSizB4Soorw5uK/xy9pJB1tUW1VgA5O7Z/NG6y6JO8eTJVNX1/StqNz4/qa7f9E6zkIDg7p66cGPyGEdAXbcl8SQkxueMLo6ymGthEsjFDzCN47mGr2/w+t19CfHCwdG2Z1JXRCiH1z46h+miEDwTRjdNUcwBn72ZlsfXzzmM61jLTG9eym0f3llnGG/Vz/RbIcSS0wy/9l6PNuOC43MKpNCOkGNLYJIQ7JbRMi1MmAdkgnLn7Tn9vU1NTVyWufJakaOiIgt7ShVksIIR0FbRvRwhGgx7i52BqfoZ01YoJ9NLJtDywfFy7XDg5Whf9XdybKuZyOtdLrrHYDHB1weEwcGGDyzyeE9BxobBNCHBIIk81rWKyiHRr62ZqDDYfTtS0MWnxBPbinZREQQszD3KFIH3eSczmlqoptakora2R7QpY+XjImzG4Ej7Cfd80YqPocUG5//uMz2gXClCJQ2xocHOjSAccHIYR0Fc4ghBCHBSnd6LmdnFuqPWRNzclLl2XzsUv6+O6Z0RLsZ7uq0IQQ+9PdgJAl2BZv+uj2jpNZmpET5u+lqvb2BAzgB66LlahAb41AP7/ttKr2m4LE7BK9ZsDRMWdoiEk+kxDSc6GxTQhx6MUq2ueA7SczTd7m68+7zwvi5ViQTR5IqWhCiGkx1gvvT85XdWxTUVlTqynkYMmY/hbr521KvN1d5eH5Q8Xfy027QOxJyjHJ5xqPy7SYIOnl6WaSzySE9FxobBNCHBoYwlhHnsoolozCcpN97j8PpWnfV/Qrv3NylMk+lxBCmoo9Du7rq6rYO08ZUr5NwWenc6SookaCfT3kmpggsVdQUw3RNPDfYxlSV9e9cqG8ksrGLKj5DY5aQgjpDjS2CSEOTR9fDxkT7q+PP21Q3e0upzOLGkWL7p4RLV7uLib5XEIIaYmxxzPUsWtq60wi6oh2XwCGqr3rTMCh6uPhIplFFXIoJb/b7b5gr8f189Pe9oQQ0l1obBNCHB5j3d3uszndXqyiLvD1hvTxWYODZVSDIU8IIeZg4sBACfB20zZdSCc3hdJ2XmmVpl9D1dve8XRzaUy3//exSypw1tW53djua/7wfibdR0JIz4XGNiHE4RkbGSD+3m6aNnn4Qvf6sm74Kk0yLlfo4vfOKUwfJ4RYrg3YtoZ64q4CQ/Sj44bPgIHq7uoYy0D9Li7OKmyWcKmoS5/x6elsKams0dIgexOMI4TYLo4xyxJCSDsgTXLW4JDGBVVXQfudj04YFqp3TY8WHw9Xk+0jIYS0l53j6mxsA9b1vtIwRC/kl4mH6zcGvCMAIbPZDRlMiG53luKKann/SJo+XuwAqfWEENuBxjYhpEcwe4ghXfLExctd6smKOkdVH68XmT4oSMYx8kEIsRD+3u4ypaENGOqKu4qxVhvp476ejuUsXDgyVGAjx1+8LOdzOueQeP+rdCmtrJWIQG+ZM9RxnBCEEOtDY5sQ0iMI6eUpI8N66+NdXRBK23kqW9ILyqWXp6usmDrADHtICCFtY4xEo+a6tLKm0+9Pyy+TY+mXtTvDjSMdryY52M+zUVn9P52Ibqfml8mOBgfGiqlRjGoTQkwKjW1CSI9hbkOa4a6zOdpKp6NgYYvIB1g+PsLhIkKEENsHLcDCA7ykqrZO9iTmdvr9xhKYiQMCpW8vT3FEjG3ADqbkS8bl8g7VsP/tyxTNWJo0MFCG9zc4ZAkhxFTQ2CaE9BggeoPIdGFZtRxN7bhQ2qavL6pwTpi/V6OyOSGEWBInJyeZ25DivPN0VqdUtwvKqmRvksFAX+SAUW0jkYHeMjbCX43njUcvXnX7wykFWsfu5uIkd0yKtMg+EkJ6FjS2CSE9BlcXZ5nZ0OpmZweF0lDfvS3e0FP7zimRTDEkhFiNGbFBqrqNkpazWR2vS96ekKnZPIiOx/b1E0dm6dgwwSyN6P/BdlqlodXX2wcu6OOFI/trqREhhJgaGtuEkB7FnCGGyPSxtEI5m1V81e3/cTBVaurqtd57NHtqE0KsCDogTI0xCKXt7KBQWkV1bWNN8qKRhjRrRwbOBGM6+eu7z0luSWWr222Jz5Ds4koJ9HGXJWMc/7gQQqwDjW1CSI+in7+XzBgUJEjAfO3TRCmpaFtoCMb4geR8jZLcMTlS0zgJIcSaXBdncBjuT85rd/4y8vnZHFXa7tvLo8f0j751QrjEBPtIaVWt/P7TpCs0Oj47ky0fNOhw3D4pUjzdXKy0p4QQR4fGNiGkx/GDaQMltJen5JZUyZ93n2u19hHP/X2/IcVw1pAQierjY4U9JYSQ5sQE+0pUoLdU19bL7sScdrctKq+WDxtql28c0U+ce0gZjKuzs/x0Tqx4ubnImaxi2XjUYFjX1NbJ+r3J8vru85qxNHlgoExryBQghBBzQGObENLj8HJ3kfvnxoqrs5McvlAg209mXWFob0vIlKTsEvFwdZbbJoRbbV8JIeQKobSG6HZ7Qml4fv0XyWpwQ8V8dg8Td4Ti+srpA/UxHA77z+fJ0x+d0j7lcDncOj5crwPMWCKEmBMa24SQHsnAIB9NDQdv778gybml+hgG9trNCfK3Lw1R7cWj+4u/t7tV95UQQpoybVCQOgIvFVbI6czWtSe+OJenAmEuTk5y76xB4ubi3COP08zYIFUnf2Vnoka5Ee1eff0QuWVcuDjT0CaEmBk2iyWE9FhuGB4q8ZeK5KsLBfLqzkSt8cMCFWAhC5GdJWPCrL2bhBDSDG93V7kmJkhrj3eczJKhoX7NIrT5pVXy5hfJ+viWcWHqXOypfP+agarcnllUoe0bH5o3WLU7CCHEEtDYJoT0WLA4vWdmtDz64QldiOGG5Srag902IUJVagkhxFaF0mBsf3k+T8qqamTF1AFqRCJ9HCrcEAeDA7GnOwxRNvSrRcPkaFqBXBMdpH8TQoiloLFNCOnR+Hm6yaq5sfLCx2ckMtBb7pwS1aOjQIQQ+yA62Fe+NSFC3j+SLsfSL8vPPzguN44Ild5e7vq3m4uT/OTaQeLSQ0TR2gOO07lD+1p7NwghPRAa24SQHs/gvn7y+nfHUyiHEGJX3Dw2TCZHB6rGxNdphbL5eEbja9+eGClhAUyXJoQQa9Lz1DIIIaQVaGgTQuyRfr295JH5Q+Xn1w/RXtogrp+fzB8Rau1dI4SQHg+NbWJzVFVWyhu//63eE+KocJyTngDHueUYFxUgzy8bLY/MHyIP3zCUStsWhOOc9AQqKyvl6aef1nvScWhsE5ujuqpK/rruJb0nxFHhOCc9AY5zy+Lu6ixjIgLE040iYJaE45z0BGBkP/PMMzS2e1LNNhQ3QWlJ6z0miX1i/D1xz9Re0pPHeVGRm4X3ipQW83piSjifk54Ax7ll4bXROhQVFTXec5x/g59f89aLLXGqN1qsdkh6erpERERYezcIIYQQQgghhPQwLl++LL169XJMY7uurk4uXbp0VY8CIYQQQgghhBBiShw6sk0IIYQQQgghhNgiFEgjhBBCCCGEEEJMDI1tQgghhBBCCCHExNDYJmanurpadu7cKT//+c9l4sSJ4u/vL25ubhIaGiqLFy+Wjz76qMOf9Yc//EHrInC76667zLrfhFhynEOD4q233pLrrrtOgoODxcPDQ/r16ydz5szRcU+IvY/zvLw8eeyxx2TkyJHi4+Mj7u7uEh4eLrfeeqvs3r3bot+DkKvxzjvvyPe+9z0ZPXq0hISE6Djv3bu3TJo0SZ599lkpKSlp872ffPKJ3HjjjRIUFCReXl4ydOhQWbNmTbvvIcQexjnWKvv27ZPHH39cpk+fLn369NH3YKzPmzdPP48Vys1hzTYxO7jo4AQEWJCNHz9eF1onT56U+Ph4ff5HP/qR/OlPf2pXYOD8+fMyatQoKSsr0xN55cqV8pe//MVi34MQc41zKFnCUIHBAUXLa665Ro2YixcvyokTJyQmJkYOHz5sle9FiCnG+blz52TmzJkqaorF2eTJk8Xb21sSEhLk1KlTus1vf/tb+dnPfmalb0ZIc2BIwKiIi4vTzjeBgYGSlZUlX375pZSXl8ugQYPk888/l/79+zd738svv6zjGON/xowZ0rdvX9mzZ49kZmbKkCFDZO/evWqYEGKP4zwpKUliY2P1MbadMGGCBAQE6Br90KFD+vyiRYvkgw8+UIcqMfSqJsSs7Ny5s37ZsmX1u3fvvuK19957r97FxQUOn/q33nqrzc+ora2tnzFjRr2vr2/9ihUrdPuVK1eaec8JMf84r6urq581a5a+ds8999QXFxc3e72ysrL+0KFDZt9/Qsw5zhcvXqzPL1y4sL6kpKTZa3/+85/1NVdX1/q0tDSzfwdCOsL+/fvr8/Lyrng+Nze3fvr06Tpmv/3tbzd77ciRI/VOTk56HmzZsqXx+dLS0vq5c+fqe3D+EGKv4zwpKal+zpw59Vu3bq2vqalp9p5du3bV+/j46HuefPJJi+y/PUBjm1gdGM04MXEhaouXXnpJt1m3bl39E088QWObOMw4X79+vT5/ww03WG3fCDH3OIejFM8fPHiw1ffFxsbq6x9++KGF9pSQrgNnE8ZrYGBgs+dvvfVWff6uu+664j0pKSn1zs7O+vqpU6csuLeEmHact8dTTz2l74mJiTHrvtkTrNkmVmfs2LF6n5aW1urrZ86c0Vqna6+9Vn7yk59YeO8IMe84f/XVV/UeNbCEOOo49/T07ND7mV5L7AFXV1e9h7aGkaqqqkbNgu985ztXvCcqKkqmTZumjzdu3GixfSXElOO8u2v6ngiNbWJ1EhMT9R5iUC2pra2VFStWaO3T+vXr263pJsTexjnqoo4dOyYuLi5ap42ap//93/+VH//4x7J69WrZsGGDLuAIsff5fMGCBXr/5JNPqu5GU/7v//5P3wfhtKlTp1pwbwnpPMXFxbJ27Vp9DK0NI2fPnm0c26hjbQ3j80ePHrXIvhJi6nHenTV9T8XgsiDESkAw5M0339THy5Ytu+L1F154QQ4cOKCCIxCJIsSRxvnx48f1HoJREPt76KGHVO25KdHR0RoFgTggIfY6n2Muh4gaIn+RkZEyZcqURoG006dPy8KFC9XoNkZSCLEVtm/fLu+++66qMBuFo2CIzJ8/X5577rnG7ZKTk/Ue4pZ+fn6tfhYEqJpuS4i9jfP2gLPJmK3X2pq+p8KrGrEaNTU1cuedd6oSMyIa99xzT7PXoWz7xBNPaMTv/vvvt9p+EmKucY5WSCA/P1/H+PLly3XMDxgwQMf/Aw88oM4mXOygSg6jnBB7nM+hyLxr1y4tBXr77bebtQiDAYIWd2h5R4itAScR2jI2BWniL730krZIMgLDBECdvy18fX31vqioyGz7S4g5x3l73HvvvepIgnL5L37xCzPtqf3BNHJiNZAqi36tMCDef//9Zi0CsHBD+rizs7O88cYbek+Io41zY+dFjHekzyJtfMSIEbogQ+Rvx44daqRkZGSw1zax23EOEL1GLd/mzZt1LKOeD4Y5DHCMcWR1oC8xSocIsSXg9MRcjZIetD1Ci7qtW7fKsGHD2B+eOAzdHedPPfWUGuvQ5/jXv/7F4EATaMEQq7Bq1SqtwUZvPhgUgwcPbvb6b37zGzly5IjW96EvJSGOOM6bphq2jAQaX0e00NjfmBB7HOdwJiGlEAs4pIojuh0eHq495SF8ifRF9OzGe//2t79Z7XsQ0h5ubm5azoYe2jBCCgoKdH5GL+Km83lpaWmbn1FSUqL3GPuE2OM4bw1Evx9//HEVUkPZm1EIkBigsU0sDiIYqOlAXRMWWUblwqYYlToRBZk1a1azm7EmEGmIxucIscdxjnrs1h63tg2i24TY4zhHKQRSFLEQu+WWW654HUa6UUCNTiViD0yePFkjfsjQOHz4sD6H8h9QWFjYmFLeEqNCs3FbQuxtnLfktdde0+sAspk++OADLXsjzWHNNrEoDz/8cGP9BxZmbSl2Gtm7d2+7Yjy4EWKv4xwRQERDsDDLzc1tdRvj88ZaP0LsbZynpqbqPQTRoLzfGsaaQOgXEGIPGGuzs7Oz9R5ZeBjjEImCYTJ79uwr3mM0WMaNG2fhvSXENOO8KevWrVO9GaOhDaFLciWMbBOL8eijj6oiLRZVSBecOHFim9t+/fXXWjvS2g0CUmDlypWNzxFij+Mcyss333xzuxE9fAaYNGmSmfaYEPOO87CwML1HOqKxLUxr0W8wcOBAM+0xIaYDTlC0bQTGsgkYHEZjA6rOLblw4YLs27dPHy9dutSi+0uIqca5kT/96U9y3333NRraixYtstJe2gH1hFiANWvWwCKu9/f3rz948GC3PuuJJ57Qz1q5cqXJ9o8Qa43zU6dO1bu5uelt8+bNzV57/vnn9fNcXFzqjx8/bqa9JsS847yqqqo+LCxM3zNz5sz67Ozsxtdqa2vrn332WX0Nt927d5t57wm5OgkJCfVvv/12fXl5+RWvnTlzpn7WrFk6XqdMmdLsta+++qreyclJ5+ytW7c2Pl9aWlo/d+5cfc+yZcss8h0IMdc4f/3113Wcu7u7X7FuIVfihH+sbfATx+Y///mPLFmyRB8jzXD48OGtbhcUFCQvvvjiVT9v7dq1KpyGyDZ6ExNi7+McCp4//OEPtb8l3mts/QUFZ6Td/vGPf5S7777bIt+DEHOM808//VRuuukmTbGFOBRqAVFCgajJuXPndBu0ioE4JiHWBir5SANHCi10CCDoB5VmlERAvBVzdVxcnGzbtk37xjfl5ZdfVnEpJycnFQAMCQmRPXv2qO4GUs1RHofzgxB7HOfIPEUZBMzHoUOH6lzeFkaNpZ4OjW1idnCy/eAHP7jqdlFRUZKSknLV7WhsE0cc54cOHZLnnntOF2VIt0XbjBkzZsjq1auZQk4cYpyfP39ea7zRIgwptVApR29tLNagUD5v3jwz7jkhHScnJ0eV8zEfw+mJv6urqyUwMFD7yEPoD+cBRP9aA2VBaJ108OBBVSeHobJ8+XJ57LHHmnWhIMTexrnRQO8INDEN0NgmhBBCCCGEEEJMDAXSCCGEEEIIIYQQE0NjmxBCCCGEEEIIMTE0tgkhhBBCCCGEEBNDY5sQQgghhBBCCDExNLYJIYQQQgghhBATQ2ObEEIIIYQQQggxMTS2CSGEEEIIIYQQE0NjmxBCCCGEEEIIMTE0tgkhhBBCCCGEEBNDY5sQQgghhBBCCDExNLYJIYQQQgghhBATQ2ObEEIIIYQQQggxMTS2CSGEEEIIIYQQMS3/D+6syh2WIe8sAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\Parsa\\AppData\\Local\\Temp\\ipykernel_8864\\2063796339.py:98: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " ax.legend()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+8AAAHdCAYAAABsV0iqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAucpJREFUeJztnQeY3MTZx98799599rlXTDG4AOEAm2YTMCX0BCehOkBIPiC00BIgEBISCARICCGE4kDoJBCD40KxCQZ89hmbYhsO4+vn3rmzfbvf886hPa12JI3arrT6/55nT3vSaOo7M5qV9H8LkslkkgAAAAAAAAAAABBaCnOdAQAAAAAAAAAAAFiDxTsAAAAAAAAAABBysHgHAAAAAAAAAABCDhbvAAAAAAAAAABAyMHiHQAAAAAAAAAACDlYvAMAAAAAAAAAACEHi3cAAAAAAAAAACDkYPEOAAAAAAAAAACEHCzeAQAAAAAAAACAkIPFOwAAABAATzzxBBUUFIgtCJahQ4eKj57bbrtN1P/bb79NYYHzc/TRR+c6GwAAACIKFu8AAAByys6dO+muu+6iCRMmUOfOnaldu3Y0cOBAmjRpEt14441UXl6e6yzmBatWraIf/ehHNH78eOrTp4+oZ17wnnzyyTR//vxcZy8v4IU5L9ABAACAIGgdSKwAAACAAtu3b6cjjzySli9fTiNHjqQf/OAH1KtXL9qwYQN9+OGH9Nvf/pZGjBghPlHj9NNPp8MOO4z69+9PYWDFihX08ssvU0lJCR1++OHUtWtXqq6upn//+980a9YsuvPOO+nmm2+mKBKVHx8+++wz6tixY66zAQAAIKJg8Q4AACBn3H///WLhPmPGDPrrX/+acddyzZo11NjYSFGkW7du4hMWTjnlFDrzzDMz6rimpkbcjb/99tvpJz/5CXXv3p2iRlR+3BkzZkyuswAAACDC4LF5AAAAOWPRokViy4tG2ePGw4YNky541q1bRz/72c/E3Xp+/Lt3795iYfrxxx9nhP3888/pwgsvFHFx2J49e9JBBx1EV111FSWTyVS42tpauvLKK2nUqFHUoUMHsYjdd9996bLLLqOtW7emwvH3X/7yl7TffvuJx/z5Djbn4/zzz6e1a9cqvfP+v//9j0466SSRl/bt24sy3nrrrbRr1y7T96Tr6+tFGlxWzh/f1XfyPjeXXVbHxcXFdMQRR9CePXvS8u83DQ0NdO+994q65x81OnXqJB7bP+ecc+ijjz6S1hs/FXDooYeKu9X8qP9FF10k6kHlnXcz2Eb4tYwePXrQu+++m/ZDEf+INHjwYFFX/MTEBRdcoFwnnOd33nkn9V37cBxW77zzcd7/5Zdf0j333EOjR48W7cv29eyzz4owu3fvFk9FcBnZXg488EB64403TJ9mYVvaf//9U3b87W9/O62sTm0eAABAOMCddwAAADmDH5FnVq9eTePGjVM6h9+B5wVQVVUVHX/88XTaaaeJxfxLL71E//3vf8Uj1N/61rdSd5V58cfv1fNi+bvf/a74zgv6P//5z2Kx1Lp1a7Fo5gXsV199JeLkR955wcQLupkzZ9K1114rFpy82OeF0AcffCDCn3DCCVRYWCgWeK+++ir98Ic/pCFDhljm/4UXXqBzzz1XLBA5P3379qU5c+bQr371K5F/XpDzAk3Pli1bxOsFnAdOg8v73HPPibwsWbKEDjjgANdtsHHjRlEeXiAPHz6cgoJ/eHj++efFwpN/TOHyV1ZW0ltvvUWLFy8Wi3o9WnueddZZNGXKFHr//ffp8ccfp4ULF4pXKnjx7RRewPITCPzDAcej1RuXn+uSbYM1AHgxy7bw9NNPi0Uy/8hkVze8YOYfHNgW+LuGql1fffXVIh+cv1atWomF+/Tp00U5H3zwQfr000+FDfOPIM888wx95zvfEY/h65862LRpE02ePJk++eQTYZ+8CN+2bZv4EeSYY44Rtsf9hVG1eQAAACEiCQAAAOSIf//733zrO9mlS5fkNddck/zvf/+b3LBhg+U5hx9+eLJVq1bJ2bNnp+1ftWqViGfs2LGpfQ888ICI//7778+IZ+PGjanvr776qgh31VVXZYTbvn17sqGhQXxfvny5CHfaaadlhOMwHFbj8ccfF2F5q7F169Zkt27dku3atUt+9NFHqf1NTU3J7373uyL8r371q7R4eR9/Lr/8chFO429/+5vYf+mllyadwPV06623Jm+55ZbkRRddlOzdu3eydevWIr6g2LJlS7KgoCA5ceLE5N69e9OO8f+bN2/OqDf+GNv4hhtuEPt/+tOfpu0fMmSI+OjhMnLYt956K2VrHTp0SO6zzz7JtWvXpsLt3r07OXToUGE7S5cuTYtj4cKFwtZOPvlkpXIeddRRIk0z+BiH0XP++eeL/aNHj06uW7cutf+DDz4Q+7t375488sgjkzt27Egde+6558Sx//u//0uLa/r06WL/o48+mra/vr4+OWjQoGSfPn2SX3/9tSObBwAAEB7w2DwAAICcceqpp4pHqXldw1u++8mPhfNj6D/96U/FHXI9ZWVl9N5774m7uBxWDz9uzGrqLMxmfHyeHwk2wo+sG5GF0xTw7cJxGA5rBd8B5ceR+fFvvgOtwXfvf/e734mnAGSP2fOd4rvvvluE0+A64PB819oJ/JQDv9/OAnV///vfxZ1cvqN98cUXU1DwY+HcxvxEgb4MDN9llr1nz3fbjW3Mj45z2KeeeooSiYRy+o899hidccYZNHbsWHH3nR+N1/jPf/4j7j5fd9114t1/Pfy0A9/hfv3118Ud7CDhsvGrARr8xAjf7eenLn79618LG9DgV0TatGmT9roBizzy0xjHHnusePxfDz/dweVbv349zZs3z5XNAwAAyD14bB4AAEBO4ceFedE9e/ZssTAvLS0Vjw//6U9/EosuXpDwIp/hR6cZfu+Z/XgbWblyZWrLj0TzI8jsbo7fqefH6fkx96OOOirjEWh+1JjfcWZ1e14Q8aPTHI7f/9W/J87/86L7n//8p3hsnx9B5kf4+dFo46JUBv/4wMh8ffOCkvPFi2t+b7lLly5pP0wYfxjghXtRUZFY3DmBy8YLaX5Emhetjz76KJ133nniUfQHHnjA9vx//etftGzZsrR9XB4r/+WsCzBt2jSxCGaXgGeffbYIf8ghh4hFqAx2FWiE64Drml8t4HfE+UceO+677z7xSgP/EMCP4usXwXqbYld6Mpuqq6sTPxRwuxx88MEUFLLH69kmuZzGY/yDBy/I+bUQDf4Rp6mpSQg8ysqh/RDGfYNtQNXmAQAAhAcs3gEAAOQcXqjygo4/DN+dvummm8R76XxHmF2atW3bVrzTy7BrM/6Ywe8uMyzwxYszXszwwpHfuWZYII7fMdfS43d7ORwL0b322msiLDNo0CC64YYb6PLLL08tmN98800RHy8Er7nmGrGf75jykwJ895QXVmZod2950S2DF1O8SORw+sU7L35lcH54weYGrk/+UeD3v/+9eP+Z36s+8cQTxcdu8f7kk09m7LdavDP8vvVdd90l3tfWXNJxufj9d95vdKFmVkfaflVBNX63neHFu3Hhzmg2xe+3W6HZVFDI2pjb1+oYiwway8FiiPyxK4eqzQMAAAgPeGweAABA6OCFxUMPPSTE3/hxYH4UXr+I4YUm3z02+/Aj5Rp8B/7FF18UixsWHuPFCt9NZbE4/SKH73zzI+v8aDHfIefH1PmOK9+15zvtepE9Tp9/UGARMc4nP4LPImX86LsVWv5liukM50sfLluwYBmjol7PdWSsb9mdXiO8OOdH9flOMn/4qYp99tmH/vjHPwrPAUbM6kjbryqmxulMnDhRPOEhe7JAq2tewFrZFN+VDjNaOfgHJaty6MX0VG0eAABAOMDiHQAAQCjhR3eNd0o1FXnNxZwT+PFsdq/G73vzIo4XMvy+sxF+/J0fU77++utTCxh+7FqWP37EmBc6c+fONQ2nR3unWrZIZuV1VtLnR+f1d92zgfb4tdkj7H7Dbvv4vX92rcaPwsvqTbtjrmfHjh3ikX1eqKoq47NaO7/nzY+8s1s0/rHAL5syoj114fZpCC/wKwhsk27KoWrzAAAAcgsW7wAAAHLGI488Yiq4xo9nsyssFijTXHqxiBcvtniBwe/CG+G7hpqvbYbdqMmExrS7t5pLNnatJbvTawzH74jzxy6cGSx+xneMWSCO09TgHxJ+/vOf0969e9P8gvsJ14Xer70Guzb7zW9+I77bPTLvFr6zaxQRZDZv3ize0ZbVGy+42VWcHhZu43f8+R19FY0BDbYh/oGFF7hXXXUV3X///Wltwneg//CHP9CCBQsyzuVH02U+0mVoIoj8Q0y26devH51zzjlCN4JfhZC1NWtJ8CsSTmweAABAeMA77wAAAHIG+9BmX9QsPMY+p4uLi8U7ufwIL9955QUav/euV77mhTv7rP7e974nFmEsgMaK2RUVFeKuIy8UWUGdYX/V/AMBi3OxP2y+Y8uPuvP7vbzQ4vetGV7YsRo354HfA+dH4/nRbr77yIsYvrvO8F1fVi3nHxH2228/sWDix+f5hwbOq+zxbz2cPgvEsZ93/hGCH93n9+V5ocqLa46X8xEE/Dj1F198IdLlxSrnl+/0cxuweB379ebyBwHXET91wL7cWfBvwIABwr88q+/z4pjTNsICaiw4yH7eNe0C9gnP7ch6BU7RFvD87ju3Ey9uecu2xa9V8A8X/Gg8q7WzKj3fxeYfNtgO2R40MUQr+FyOi9XgOT62HS4zlyMbcF9h4T2+g862X1JSIsrNPyawECSL1tXW1opXGFRtHgAAQIjIta86AAAA8WXlypXJ3/3ud8mpU6cmhw0blmzfvr34jBgxQvi/Li0tlZ63adMm4af8gAMOEL67O3funBw1apTwc/3yyy+nwr3//vvCDzqHY3/ZHJbDsZ9wva/vTz/9NHnllVcmx48fn+zVq5fwwz58+HCRh08++SQVrrKyUvgaP+yww5J9+/ZNtm3bNjl48ODkGWeckVy0aFFaHmV+3jUWLFiQPPHEE0WeOA728f2LX/wizZe3lW9wK//mZrzwwgvJs88+W5SrU6dOyTZt2iQHDBgg8m70p+437Mf9tttuS06ePDnZv39/Uebi4uLkCSeckHzjjTdM6+1f//pX8pBDDhHtxu1ywQUXJGtrazPiV/HzrrF169ZkSUmJOHbPPfek9ldVVQkbYPvg9u/atWty3333Tc6YMSM5f/58pXLu2bMnef311wubaN26tUiDbUjFz/uaNWsc+Y03a/tdu3aJPjVx4kTRzlx33LdOO+205FNPPSXy6MTmAQAAhIcC/pPrHxAAAAAAABgWUOMnIvjVgqBeIQAAAACiCN55BwAAAAAAAAAAQg4W7wAAAAAAAAAAQMjB4h0AAAAAAAAAAAg5eOcdAAAAAAAAAAAIObjzDgAAAAAAAAAAhBws3gEAAAAAAAAAgJCDxbsOfoNg27ZtYgsAAAAAAAAAAISF1rnOQJjYvn07devWjeaWraFOXbpkHOdFfWLvbips3ZYKCgpykkcAggZ2DoKmZESvUNh5Q0MDtW/fPhZ2vqh8Y66zAHIAxnMQB4K08zDMV3EjzvNViYK94c47AAAAAAAAAAAQcrB4BwAAAAAAAAAAQg4W7wAAAAAAAAAAQMjB4h0AAAAAAAAAAAg5WLwDAAAAAAAAAAAhB4t3AAAAAAAAAAAg5GDxDgAAAAAAAAAAhBws3gEAAAAAAAAAgJCDxTsAAAAAAAAAABBysHgHAAAAAAAAAABCDhbvAAAAAAAAAABAyMHiHQAAAAAAAAAACDlYvAMAAAAAAAAAACEHi3cAAAAAAAAAACDkYPEOAAAAAAAAAACEHCzeAYgESaqurhJbAAAAcR+/MScAAEAcweIdgAhQXV1NPXv2ElsAAADxHr8xJwAAQDzB4h2ACDBgwADatGmj2AIAAIj3+I05AQAA4knrXGcAAKBCAQ0YMDDXmQAAABCK8RtzAgAAxBHceQcAAAAAAAAAAEIOFu8AAAAAAAAAAEDIweLds4prlBVfg8x7lOvFS/ma9yeTCd3xJFVVVYqP2X7rcFbpuc2n/Xk1SudZ14NWruzbgjFNWR5kbeU0XrN9bvPpPF3z/AdlM0kLG3ZbvmBJJpP0+eefi61qONVzco1ZPuX7VfqrUqqhaNfsgjqKNyrtqTLv+Jmm2/SswrmZF/MR9bZTmSu0MIlEwjKsm3mH45w7d67Y6uNZvXq1+BjTNKahDxuluc8Zfl6neb9u83ptjMW7hJraGmUV1ygrvgaZ9yjXi5fyafuXLl2aOs6fhoZG8THbbxXOKj23+bSjrq6OeiicZ1cPWrmybQvGNGV5kLWV03jN9rnNp5t0zfIflM0Y21Zvw27LFzRffPEF9e/fX2xVw6mek2vM8inbr9JfVQhLu2YT1FG8UWlPlXnHzzTdpmcVzs28mI84aTuVuUILM3/+fMuwbuYdjnPs2LFiq49n165d4mNM05iGPmyU5j4n+Hmd5sd1m9dr44Jkfv204olt27ZRt27daG7Zl7Rl27ZvVFwLUse5qhJ7d1Nh67ZUUKDt519OqjPCRoMg8x7levFSvub9xcXFVFNTk1ICrqqqSikEy/YPHDjQIlyBh/p0fl6znTdSXf16GiDyVeC6HrRyZt8WjPmS5VPWVnb5M4/HXflUz3WT/6BsJr1t0224QCmukhG9KJuwTfOFyMiRI1NjN+9raGig9u3bp+3TwjHGc8KIrGyy/YvKNyr2V5Wy5vv4LiOadSS/bgHOUWlPlXnHzzTdpmcVzs28mHv8t/OWOioZ0ds2bbu5QgszYsQIKi8vNw2rEpcRvrPOC/TjjjuOCgub78lqd88ZjkufpjENfdhRo0aFYu5rnq/8JOnjdZr36zara2OV6yMs3qWL9zXUqUuXjOOYBEEcgJ2DoMn24l2GbPGez/h/MQSiAMZzEAeCtPMwzFdxI87zVYmCveGxeQAAAAAAAAAAIORg8Q4AAAAAAAAAAIQcLN4BAAAAAAAAAICQg8W7T+6S1NxHwXVMeHHr+sEP90FWrln8cmfmPl/mZQ2rmzgvOGlfdXd03tsirK4vo9a+/rj7kYXx4l7HybmysOrnBzUv5Y8duHfT5eRckH2CbC+zOc+ri1K3Nqg6B2eG8ydffpBt97jhws18YjU36N3FGV3DGc8Nn6s4P/qB0/nP6fVv+v/cj5YsKRVb+/DObRaLd5/cJam4j4LrmPDi1vWDH+6DrFyz+OXOzM05NTZlVXE7FTWbd9K+KmH9ags/y+Rn2lFrX7/c/cjCeHGv4+RcWVjV84Oal/LJDty66XJyLsg+QbaX2ZzndL53mi+vc7AsnB/58gO3aRivW6KKm/nEam7Qu4szuoYznhs2V3F+9AOn85/duXb/cz8aNmy42NqFd2PrUJs3VZvvnCHhn65mSTZy/367lALB4tb1gx/ug6xcs/jlzkw9XzwiNNt5Gxt3dWF1E+cFJ+2r7o7ObVv4U2dO4suOO6wwqs07cfcjC+PGxY+bc83c3tmdb+4qzg97y8e5zambLifnZg+ozWejvczmPPNrQ7U53a0Nqs7BmeH8yZcfOEujxc6N1y3eycV85WY+sZob9C7qGL1rOOP8Fz5XcX70gwKH85/dudb/8x13XrhPmDCBCgoKbcKn91G4inMIXMUBADsHwRPGxXu+E2fXO3EG4zmIA3AVl1/Eeb4qgas4AAAAAAAAAAAg+mDxDgAAAAAAAAAAhBws3n0lP1Quw0+Q6tnZIIx5As6w9xCQ2/aNrmp8+JRuo1dmb/GFxxZA9NstU3XZj/yqKkSHkSjkMcxkv/68egOJG6iD4MHi3UegMBu+eg5jm4QxT8AZVsq8YWhfp3kIQ541wqZ0G8Uye4kvTLYAot9uRtVlP/KrqhAdRqKQxzCTi/rz6g0kbqAOggeCdb4K1oVHYTa/CVI9OxuEMU8tQOBIBXsPAblt3+yoxgchyOJFtT2qgnV+l1kWn7oAUBjsFzhH3m65Hs8zVZet86sYq6JCdBiJQh7DTPbt/LDhPT15A4kbftQBBOusweJdB9TmAYCdg+AJg3pvmBbv2SDOF0NxBuM5iANQm88v4jxflUBtHgAAAAAAAAAAiD5YvAMAAAAAAAAAACEHi3dlklRdVUm1tTWUSDSZqKeqqmPq/7dSzpQpWiepqqpSfMwVrpvDVFZWiA9/5zi0fdr/+ri1rXXZMvMtV9uW10F6vlv+l+XFGFafLpehtHSxjXptZnpW6rRWacvr266Nzcpt1bayeKzrPF3JNzNsenvK8qii3Gp/XqaisCx9eb1odV5R0dyufI5ZObRjvOWwbAvuFIdVFWuDULZtaUd9n9S3udl+/XlafZm3rZcyZfYL+/5u1TfT42Ql2kQiQatXrxYf2dtbmmIth9Nveb+Zmq1sv53yrT4dzsuqVavEVp+eLB7eyvLP582dO1ds7fKpT3PlypU0Z84csU8fTpaGPl7jd7PwVuONftyThZHbY3q7mu3X+irbq3E81veB9Pibjzc1NdHs2bPFVmWcNJYjM9/247353Ozew4RzxXXV/ZnzqNpcQh7yId+nNt+qpmt3TDVOd1433NQln6PZeUXFWpo9+w2D3Vpfl2n7Muc2c9u2uw70t27tzjHvW2bzCG+1OYPrKrOPyO1Kux7QzuH/ayTXfurXp9blthvDzeYX2ZxhNT9p47c2H/z3v/8V3/VzpWw+NOZHi8P40c7n7xw3p2E8ZkxHP8cY50jjMVl4s7metxyPNudlxmM+Nie/6Wvp138q45319bxZvLJ+K1trWO3Xvttfk6uBd94V33nnCv5619dUQAn6vHwNHXroobRmzZc0ceLBtvHyuayOuWnTRhowYGDa/4z+mOy8Tz/9hPbbb/9U+K+/bhDbDh3ap84xxslh6uvrxfeioiLaunULdevWXezT/uc4tbi17TvvvGNaNlm+9Xkz5j+j/nT51pdDlhfOqz6sPt2vvlpL3bp1pcbGxrQ8yupAFoc+n8Y6lqUtq2+7NjYrt7G9jPWnYiv6c+rq6oSSL7dXv379MsLq21N/XGY32j7ju2OyMMZ9PBhp+eA20Y6b2ZO+XjTb5HINHz6cqqqq6aijjpKW48MPPxTH+P9BgwbS1q1baciQIdI2tbJJlTBOwjlB3/b6PqnZh1Y3sv3687T64n4ga1svZZL1C/3WbLwy65vGOC+YdgQtWrSI+vTpI4516tSJRo0alRaeJ3BWrOVwJSUlqW1tba04zsf4u/487Rz9ftk+/TvvlZWVQnhQy8/atWuFTa1fvz6VHp9njIf/37lzZ0b+eeE+duxYWrFiBQ0dOtQyn/o0WfjwwAMPpF27dtHUqVNT4WRp6POirwvGLHxlYwfT8UY/7mnjsT6MzB7t7Ek/BnBfLS//kvbbb7+08VjfBxgtfu34K6+8kurvp59+uu04aSyHsX/p01WZa8zSMPYBuz5lHB9V685uv3Eclc4lGzdQv6K+VFe/jnr26m15raGSD7N9KvOtEat6czv2ql5fWZ3rZF7W4uU2Zv0MtvPNmzfT/vvvR6tXf56yW7vrMm0fC33p5zatDDLbtrsO9LNu7c6xupYyu97kbUNDo5gzli9fQSeccEJaHzGzK+16gH/Y43P4umDy5Mm0eeM6ooJW9HVDY1q6XuZvzsMJE0ZYjuH6eUKPbM6wmp+08VubD3r06EEdO3akDh06pOZKbV4ypiubU4xo8xrPMV9//TVt2bJFnKM/ZkxHP8cY50ieY/THZOG1vBrnes7vp59+Sr179xb50eZK7ZwnXv+f6dhcV1cn+pr++k+lj5pdj2tofdgYr6zfytZkVvu1snD/tromZyBY56tgXZKqKiuJkk3Uf8AgWrZsmUQ9VVUdU/8/WSiPyhStiaqq+JcaooEDB5ooXDeH0ZqWF2C8n4/zPu1/jlOLW9ty5ykrKzMpW2a+5Wrb8jpIz3dLOWR50dyAaGH16fLFNnekiRMnWqjXGuvJrJ7T61iWtry+7drYrNzp7ZVZf/a2oj+H27NFybcgI2x6e+qPmyujZwq/yMqWvi9TUbj5uLk9tdSLZpuJRJLWrasXYXkCkJVj/Pjx4hj/z+nxQDpo0CAXisOqir9BKAO3tL2+T7bYR3PdyPbrz9Pqq7kfyNrWS5ky+4V+azZemffN9Dj7JLfQiBEjUq5keDI3igxpirUcrry8PLVlBVtGpmYrU7k1U77VFu/t2rVLxc/htHrn8Fp6/L8xHu1OgTH/fOdg/vz5dNxxx4l9VvnUp8kfvms3ZcoUKixsrjuzNPR50dcFYxb+pYXLTccb/binjcf6MHJ7tLOnljGA+2rfvkVUWKidTxl9gGmJv/l4v379xY8h/GNGXV2t7ThpLEdm/0ofQ+3mGrM0nHqYcK64rro/fRw1a9vE3j1U2LqNZd9Vz4d8n9p8m1Ezttc/zsde1esr83OdzcsFuqcrlgg75+O8MJk69Xid3Vpfl2n7OO30uS29rzDaeXbXgf7Wrd055tdSZtebvOU64Tlj/PgJtGyZ8VpBblfa9cC4cePFOeK6oKaG+hX1Edct5mOZG5LUO7HZcgzXzxNpZ0rmDKv5idHfveZFMi9qeSzX5kptXjKmK5tTjGjzGqfx1VdfiQWqlg/tmDEd/RxjnCO1HyCM9WDcJ5vrtacMuIw852lzpXbO+oLupmNzMpkUfS39+s++j5pfj1NaHzbGK+u3sjWZ1X6tLGzz1tfkWLw7BmrzAMDOQfCEQb0XavMgDmA8B3EAavP5RZznqxKozQMAAAAAAAAAANEHi3cAAAAAAAAAACDkhHLxfsEFF4jHXqw+/LijDH5f4eyzzxbvLPDjkMOGDaP/+7//o3Xr1mW9HNEiCFXtsOJUKd9d/PGoS+APsBkAgukHYepbXhTgw1SOMOGn+j0AwA47Dy5Ahr9jUGsKMUcccURK/MBIq1atMva9+OKLdO6559LevXvpkEMOEQv30tJSeuihh+iFF16gd9991zS+uMOiCax62Cye4I+qdtjLyqIwrAzpd5njVJfAH2AzAATTD8LUt4x5scqbk7BxRlYv/J1VzLXvDOoOAH9gYTkWDeStUWEfyPF7/A714n3GjBniLrwKrPB3/vnni4X7I488QpdcconYz34gOY5//OMfNH36dPrggw8g2iJBU0PUVBLjUFZWe9QrQ/odfxzqEvgDbAaAYPpBmPqWMS9WeXMSNs7I6oW/65WeGdQdAP6gqdLjZqg6fo/foXxs3g3333+/8BXILge0hbt2h/7hhx8WKvKLFy+mOXPm5DSf4YXdH1i5Qsu/srI7kmDKHKe6BP4AmwEgmH4Qpr5lzItV3pyEjTOyemHXgIPEp3k/6g4Av9DcxOFGqBP8HYPyZvH+yiuviC3fXTfSuXNnOvXUU8X3l19+Oet5AwAAAAAAAAAA8vax+bfeeotWrFhB27dvp169etGhhx5K06ZNo3bt2qWF4+P8CAdz8MEHS+Pi/TNnzqSysrKs5B0AAAAAAAAAAIjF4v2pp57K2MciCX//+9/phBNOSO376quvUt8HDx4sjWvQIH58imjNmjWB5BUAAAAAAAAAAAiKUD42f9BBB9Ef//hH+vjjj2nbtm1UX18v3lU//PDDqba2VjwC//bbb6fdedfo1KmTNE5+dJ7h+OzYsX0b7di2jRobGoQrhPRPgmqqKsVWdqza9JjTT4KqKivERxZfItFES5YsFlvvaTnPW2Y5/Sx7cHXqPi4n51q3nXm8fteh07iDqJ/s1bn/6WfTplpshvu0aluZhzXmyyqfXuvIn/EgkUjQ6tWrxdZqn5t43MalmhYLo+rjDiItP2xVfVzKXR6991e35bRLO+ixxG16ZuO82/x6nSvCMme7Tcdq7HQ67trFHVy9OLtG9Hts8Dofm+Un233Q+hO2cd7rHJqN8nhLI1ztnwzoo0JBUjVkCOCsnn766fTvf/9bLPCXLVsm9r/33nvCrRyzZ88eat0684GCuXPn0vHHH09t27alxsZmFyJGeGHPwnYaF/7karrop9ekpV9fW03devSirVu3UL9+/dPOr6urpe7de9CWLZszjjmF49JcnbRv3y4jvuXLl4unDCoqKujAAw/0lJabvBnL6WfZ7dLKRVxOzrVrO7N4GT/r0GncqfCbN1HfPr2poFUbZUESs/rJZp37nb7febQ6l9Fshseh0aNHK7UVT4KysMZ8WeXTax25GQ8mDumRsY+fiioqKhI/1rKbT7N9dpidI9vf0NBA7du3d1xmY5zskpRfzdLidpPvoJn1wafK41Ku8KO/Ohl/naQd9FjiNj2zcT713eF4rpJukONJUHGppsOYjZ3aMdVx1y5uP/JrFo+Ta0S3fcZp/pzYtCw/VueLhU/THkfXLarI5ismbOO81zk0G+VRTWPJ2ub+kssxOFccOaY4vxbvzEcffUTjxo0T33lQ4sfh+b14bXDasmVL2gJcL2h3xhlnUO/evWn9+vWWi/dXFnxEnTp3oTZt21Jb3fv14lejvY1UX7+eigfKVAOTVFNdTcXCFYDXwSNJ1ZqrE0la/MtTWdlSGj9+glBNzy6ycvpZdru0chGXk3Ot2848XvK5Dp3G3Ry+f3ExJfbuocLWbR1Mgmb1k7069z99v/NodS6lbIb/r62pUW4reVhjvqzy6bWOnI8HJSN6ZcaSTKbcz2h2J9tnmxuTc4z7+X9t8e72Yk+Lc8SIEVReXp4Wt9N8B82i8g0OxqVc4Ud/dTL+Okk76LHEbXpm4zy5HM9V0g1yPAkqLrdzZeYx9XHXLm4/8iuPx9k1ots+4zR/6jYtz4/5+c3X57sdXreoIZuvtDTDNM57nUOzUR7VNBaVbwzBGJwbDh/ZO/8W77t3704J1vEd95KSkrQ75vxr49ixYzPOe+CBB+jKK68Ud0fYZZwMLZ65ZWuoU5cuGceDHBwACAuwcxA0ZhdD2cSPxXuUkF8MgXwH4zmIA7lYvIPgiPN8VaJgb6F8592KjRtbGrTLNwvsrl27il9xGH58UYa2f8KECVnJJwAAAAAAAAAA4BeRW7w/++yzqQX7Pvvsk9rP78IzzzzzTMY5O3bsoNdee01850fnAQAAAAAAAACAKBG6xTuL0L366qu0d+/etP2sTPjYY4/RTTfdJP6/4oorqE2bNqnjV111FXXs2JHmzZtHjz76aGo/qwBffvnl4l34Qw45RIjW2VFdU0VVVZXi/Yp0kkIwIXN/epjq6qpmVUTd1vocEAxJ0Y78MbYHK7CWli6mysoKxbZpbteWsC1xo22t6slruKggK4+qjaSPGflTJyB6+NEvZfacFGMtj7m8P+OMZIKWLCmVHstP8m38Cwon82xznTarrGu2JNsHjHD9zJ49m5qa9qbqqWVfE2wVgJARusU7+2z/zne+Q3379qUpU6bQ97//fTrppJOEKuGMGTPEO4rnnnsu3XrrrWnnFRcX0xNPPEGtWrWiSy65hA477DD63ve+JxRBZ86cKdQN+a68yrswjQ27hdJldXV12n4WSmClQ96awef07NmLli5dmrY1xgWCh+uc25E/xvaYM2cudejQgSorK5XaRmtXLaw+brSteT15DRcVZOVRtRHjmJEvdQKihx/9UmbP/KmoqBT6ArzfCO8bNmy49Fg+km/jX1A4mWe1OuW5XbMl2T6QCdcPa0X99dFHU/Wk7XvuuedgqwCEjNAJ1rEbARaX43fU+Tu/485Z5MX3oYceShdeeCFNmzbN9PwlS5bQXXfdRQsXLqStW7dS//796eSTT6Zf/OIXIg4rNMG6J2YtpI6dOtNAg+pms4/3CioeONhCvZN/6a0WPybUsBrpN9sBea6OGN5f7b9RLB0wIK092C54gmKbYI8FSgry1dW6dmyJ22gn8RZ+MdaT13BRQVYeVRtJHzPyp07CLQAEwbqg+qXMnkn8UMrugSZOnJgxf/LcyuMxa9Jk33tKLsje+BdtwTon82xznfLcXlZW9o0tFUj2xcG+nMF32XmxPnXqFPH0K9cT203zvqniidOwz0sQrMsvIFgXscV7LoHaPACwcxA8YbgYwuIdxAGM5yAOYPGeX8R5virJR7V5AAAAAAAAAAAgbmDxDgAAAAAAAAAAhBws3nMG1GZzD9oAgDg9Vvn555+LrR7ZPr/iBhhjAQAARI1kqOcuLN5zBNRmcw/aAID48MUXXwjhKt5qsCiqcZ9fcQOMsQAAAKJHdcjnLizecwQrd27atDGlxAuyD9oAgPgwcuRIqq2tFVsNdkFq3OdX3ABjLAAAgOgxIORzV+tcZyC+FNCAAez6BOQOtAEAcYEViEeNGpWxn/d5VSc2ixtgjAUAABA1CkI9d+HOOwAAAAAAAAAAEHKweAcAAAAAAAAAAEIOFu++qw02n5NMJizODbeKIch/2D6XLCkVW2DWN4391Gu/Rb8PE6wMz4J1UIgHweBXf8e4Eb25IkpEOe/xqIdcejORpa26T78/kUikHXcSh/O2SQa8/vL72tA5WLz7rDaonbN06VLTc8OuYgjyH7bPYcOGiy2Q901jP/Xab9HvwwUrwxcVFUEhHgSCX/0d40b05oooEeW8x6UecunNRJa26j79/vnz56cddxKH07aptgjvRzv7fW3ohoIkbjuk2LZtG3Xr1o3mlq2hTl26fPNrSvU3aoMF4tegxN7dVNi6rYXAUfM5xcXFVFNTkzpXFkZ+DIDg4TvuvHCfMGECFRSk/4anZuf5ir5vkqGfeu236PcaJSN65ToL4k7AypUracyYMVRYmP+/Yy8q35jrLMQMv/q7t3jiPZ7naq6IEvkxL3m3c/N6yPV8xWXjBS17M8l2H5alrbpPv3/EiBFUXl6eOm4Xx/tfbvJgo0mL8H7YuzEOf/uQir1h8W65eE8HkyCIA7BzEDS5vhjS7LyhoYHat28fCzvH4j2eYDwHcSBIOw/DfBU34jxflSjYW/7fbgAAAAAAAAAAACIOFu8AAAAAAAAAAEDIweIdAAAAAAAAAAAIOVi822LmAiC8biWcka1y5Et95Xu5k1QTqfwCAEAcyBfXZLnGru5Qt9kB9Rx1jK7dsuPSLp/sxn1ZsHi3wcwFQJjdSjghW+XIl/rK93JzPnv07EV1dXW5zgoAAIA8c02Wa+zqDnWbHVDP0cfo2i0bLu3yyW6qPZQFi3cbWPp/06aNKXcgdvujRrbKkS/1le/l5nxu3rSR+vXrl+usAAAAkMwlUZtXwoRd3aFuswPqOfqwS7fa2lqxlf0fBPlkNwM8lAWu4nTAVRwAsHMQPGFwvQNXcSAOYDwHcQCu4vKLOM9XJXAVBwAAAAAAAAAARB8s3gEAAAAAAAAAgJCDxTsAAAAAAAAAhIDsKLeDqCrcY/EOAAAAAAAAACEgG8rtILoK91i8AwAAAAAAAEAIyIZyO4iuwn3rXGcAAAAAAAAAAAAJxfxRo0blOhtAUEADBgykMIE77wAAAAAAAAAAQMjB4h0AAAAAAAAAAAg5WLz7pjQoC6Pflyu1wrCoJFrlw239qp5rFdZp/SSpqqpSfFrO8ZL/IPBaJ27icZuXsKdh1oeNcWb+r9lJMpkQx7St93x4LZPb87M7lqiq7WrhEomENLwsHg47d+5cy7j15wWh/GsWp9P9smPW+XU7lrptf7e265e9+TE++zH/OCFpOmbwviVLSsU23NcCfl3/yO0nvW6y3T4q+cxVfE7mKdV0vfahbPb53NgCj7WrV68WH9k4rJ+njOGcpGE3zsvyYYxj1apVNGfOHGpqakqbO2VzqNk8qDInWs3NdvOcH+N1MpkwXK+r2rZKv3G7FvAHLN4dKA3WWCgNytQI9ftypVYYFpVEq3yo5NEsjJPy2bWRajkaGhrFRzvHS/6DwGudaNT4kGe7vFSHPA2zPmyMU/a/ZidLly4Vx7St13x4LZPb87M9lqiq7Wrh5s+fLw0vi4fDjh07lhYuXKiUfhDKv2ZxOt0vO2YV1u1Y6rb93dquX/bmx/jsx/zjJs+yMYP3DRs2XGyd4Md47gS/rn/M7EdfN9luH5V85io+J/OUarpe+1A2+3xNjmyBx9pdu3aJj2wc1s9TxnBO0rAb52X5MMaxcuVK6tSpE82cOTNt7pTNoWbzoMqcaDU3281zfozXS5cuTbteV7VtlX7jdi3gFwVJOBFMsW3bNurWrRvNLVtDnbp00R3hX1Oqqbi4mBJ791Bh67ZCTCKd5jDNaoQFkn0kOZ4NZPnKBVb5UMmjWRgn5bNrI5X64V/b+Jc1ooEDB35zjpf8B4G3OuEhIbF3NxW2bkM1NTUe82yXFz/qJcg0zPqwsT8b02ixE97H9cjjh/v6zIzfW725Od8/Gy4Z0cs+tWRSTOSstps53maGGzFiBJWXl2eEl8XDdwLmzZtHRx55JHXo0EEav/48RiUvTjArn9P9smOysIvKN3ocS922v1vb9cve/Bif/Zh/nOdZNmbw3SS+KJ0wYQIVFNjff/F3PHdeBu/XP3L7Sa8bs/jDOu8GGZ9VvbvtC177UPB93t7O3cetOl813zEmITRnHIcZbZ7SFqxaOCdltBvnZfkwxsF35deuXUvHHXccffnll6m5UzaHms2D+u9mZbCam+3muQ2FPTyP18XFxamFdPP1umycULF3eRh3awF/7A2Ld6XFu3FwkC3eAcgPYOcgaFQmp2zYeUNDA7Vv3z4Wdt6yeAdxAuM5iANB2nkY5qu4Eef5qkTB3vDYPAAAAAAAAAAAEHKweAcAAAAAAAAAAEIOFu8A5K3CP3AG2i1KOFNYBwAAt2BuAACEByzeAfCZbCpOAv9Au0ULJwrrAADgFswNAIAwgcU7AD7DSpObNm1Mqb2CaIB2ixasUltbW5tSvjX+DwAAfoC5AQAQJlrnOgMA5B8FNGBAs1sKECXQblGCFYXZFY7Z/wAA4A+YGwAA4QF33gEAAAAAAAAAgJCDxTsAAAAAAAAAABBysHgHAAAAAAAAAABCDhbvWXUx4oe7Eas4mo8lk4kcuDUx5iso1yqq8Tqp9yDyqtIWSaqqqqSKigoqLV0swqrFoVYe6/PMv9dkxG3Xtipt76bdvIRROS9ImzWLy6+8B5GG23y4iMXGrZtTt29m4a3i4X1r1qxJO6aFTyQStvGZfVdNe/Xq1eLjtA5k6ZrlV40g+lz6GCQfB9XGI5Vx1Nn47mY+iKKrMPtrBX/GIT/i9ZKm3/jV/m7mF7m98/9LlpRKrhFU8+/keDjsk6+N+GM2v5mPCX5ec2tpOT/fbvwPwq2pSrxO0ob71fCCxXsWXYz44W7EKg7t2NKlS7Pu1sSYr6Bcq6jG66Teg8irSlvwvoaGRlq2rIzat28vwqrEoVoeq/Osvvfo2Yvq6upM68fp/yp5dhLObXu5ybdbzOLyK+9BpOE2H26wc+vm1O2bWXireHhfUVFR2jEt/Pz5823jM/uumvauXbvEx2kdyNI1y68KQfQ54xgkGwdVxyOVcdTJ+O5mPoiiqzAtzzUu6swuzlzMpdmqe7/a3838Ymbv/P+wYcMzrhFU8+/keLawu5blayP+mM1vZmNCjY/X3Nr5bsZVu/E/CLemKvE6SRvuV8NLQRI/qaTYtm0bdevWjeaWraFOXbpkHOeqSuzdTYWt2wplY/Vf7qpTLkZavquebxVfgfRYcXEx1dTUeEzHa76s8ulnOn7UexB5VWkL/nW5ihKJJK1bV08TJ06kgoJChTjs8qtyHpl/r6qifkV9qLB1u2/s3K5tVdreTbuZhXPbXm7y7RazuPzKexBpuM2Hcw4b3lNcELBbN9lYymOt1XHV8Fbx8N3qlStX0pgxY6iwsDAt/IgRI6i8vNwyPkb2XQtvlbZ2R4NhhXwndSDLg1l+9Swq35jFPpc+BsnHQcXxSGEcdTa+Ow3vpvxhoKUNEnv3GK5b/ByHnBx3X47s1b1f7e9mfpHP3XyXmRerEyZMMFwjqObfyfFsYX0ty9dGzMCBA6XzW2YdadfnbXT7vV5zN6d15qQDHVzzk9L472R+8yNNN2kHlU8VzOer/KdkRC/bMFi8B754ByBawM5BGCanbNh5Q0ODeOolDnYe54uhOIPxHMSBIO08DPNV3IjzfFWiYG94bB4AAAAAAAAAAAg5WLwDAAAAAAAAAAAhJzKL9+uvv148CsOfO++80zTcvHnzaNq0adS7d2/q0KGDeJ/x5ptvph07dlD0CUJpPZcEqSweVH6yFW+L2qoz7wF+lcGoOq+iwOu0Pf2ubyfxqSvyO/feYHVeLvtjZntlKvpatalK2xnjlNuNigqvU0X6XCr4+pGGpj7vTTnePH5n7Zgv+KG4Lu8T6f3bfHzkcOZ9QqVP+lHWbJGZB00pPZFoSis3l7GyskI6/rjzLpAtu85FPbtVkA/Kq4AXW/U7r07ScneN4tYjiH4sV/Ew4iQNv851my+VNHKvVp8MwZgY48X7e++9R/fee6/teyz33XcfTZ06lWbPnk37778/nXLKKbR161a666676OCDD6YNGzZQlFFVzjRT7g0bQagcB52fbMWrV1t14j3ArzKw2nwPG6VcL2q6Qdimk/jMFGtl+XPqvcHqvFz2R1l7GRV9rdpUpe2McZrZjYoKr1NF+lwq+PqRhqY+70U53ip+J+2YL1iVz818ata/rcZHDmfWJ1T6pB9lzRayPGhK6XPmzE0rN5exoqJSOv648S6QLbvORT3bpalSJ36m58VW/c6rk7TcXqO49QiiH8tVPIw4ScOvc93mSyWNXKvVV4dgTAyK0AvWsUGNGzdObA855BD617/+RXfccQfdcsstaeHKysqEWjerBr/22mt04oknps4/9dRTRSc688wz6cUXX4ywYF0QSuu5JEhl8aDyk614W9RW+Tx17wHey9Bs541UV7+eBqSUXlUUeJ22p9+26aTs6or8zr03WHkayKXSb2Z7ZSr6WrWpmSJ4uhJwepyycEnqndhsq8LLOFGkd6NQryJYlw3FXb36PKdjpxzvJv6XFi530I75gr13FuceMGT9W27nWjjt4jGzTxjPs1LZdlfW7F63ZOZBU0ofP3481dbWpsrN5eS8cZ6M44877wLZuu7JxRjuVkE+KK8C5MFWg/GSIrdzf65RzNTm7TyC6L2AMHYeRvyef1TV593kSyUNL3n3R7AuGcn5LS/U5q+88kp64IEHaNasWfT888/Tk08+KV28n3POOfTCCy/QjBkz6NFHH007tnbtWho+fLh4hOWzzz4Tj9JHc/EOQPDAzkHQhEG9F2rzIA5gPAdxAGrz+UWc56uSqKvNv/322/Tggw/SeeedJ95jN2P37t1icc9Mnz494/iQIUPoiCOOEN9feeWVAHMMAAAAAAAAAAD4T2gX7ywwd9FFF1FRURHdf//9lmFZaIEfj2f43XYZ2n5+vB4AAAAAAAAAAIgSrSmkXHvttbRmzRpxp7xHjx6WYTkc0717d+oiedydGTRoUFpYK3Zs3yYewWnTti21bdcutV9TjAz5mwYgNLBiezUVR+x9G9g5CJow2Fbc7Dyc5YzmGBkl4mbnIJ4EaefoO9kHdR7BxfucOXPokUceoe9973t02mmn2Ybfvn272Hbq1Mk0TOfOnVPvtdtx+uSDxPbCn1xNF/30mtR+MTA07aEEX2bg3TFgQ11dLXXv3oNqqiqoX7/+FBVg5yBo+F3zMNDY2BgbG+f3QcNGVMfIKIHxHMSBIO08LPNVnAjjfBUmQrd4Z9duF198MfXp00e8754LXlnwEXXq3EXceWfxizRBDH7XAMIvQIHigYOb7yoNHBypu0qwcxA0LBKXa7S7NO3atYuFnevnsrAQ1TEySmA8B3EgSDsPw3wVN8I4X4WJ0C3er7rqKuF+4rnnnqPevXsrnaM9Kr9z507Ld+iZrl272sbXuUtXqdo8w4OC9gHAmgIaMLD5dY2oATsHQRIWu4qTnYezjNEdI6NEnOwcxJeg7Bz9JvugziO2eOd33Fu3bk1//vOfxUfPypUrxfaxxx6jefPmUb9+/ejZZ5+loUOHiv1btmwRj9DL3nuvrKwUWy0sAAAAAAAAAAAQFUK3eGf27t1L77zzjunxr776SnzYBRyzzz77UMeOHYXifGlpKR1zzDEZ5/B+ZsKECQHmHAAAAAAAAAAAiIGrOL57rleN1H/OP/98EeaOO+4Q//MCnmnbti2ddNJJ4vszzzyTEefatWvpvffeE99PP/10yj1Jqq6uEtvcxuVnPnKBPv9RL0u2cVtfYajnbPefMJQ5/+Ex/fPPP4fKrMM6CbbenNp+LvqKH2mqxpGrsSBb6Tank0wmPKaXzTbxHy7/kiWlYhtgKj6VTxZPGK+NklRVVSk+cbpezcUYzvGwC23+hHE+tSsv74/y+BHLxbtbbrjhBvGOxOOPP06zZ89O7ee78SyA19TURGeeeSaNGTOGck11dTX17NlLbHMZl5/5yAX6/Ee9LNnGbX2FoZ6z3X/CUOY48MUXX1D//v3FFqjXSZD15tT2c9FX/EhTNY5cjQXZSldLZ+nSpZ7Sy2abBAGXf9iw4WIbFH6VTxZPGK+NOP2GhkbxidP1ai7GcI6H1z78CeN8alde3h/l8SMbFCTD+LOMCRdccAE9+eST4s77LbfcknH8vvvuo6uvvlos4o866ijq27cvLVy4kGpra8Wj9e+++66lCB67kevWrRvNLVsjFawTapZ7d/ugZsm/CFXTAF9823qJy8985AJ9/iniZck25m1vbedhsJls958wlDm/KBnRK2Mf2x1P2iNHjsyKWA2nxy6AWEk4rOI4KnWiWm+Lyje6yYFD289FX/EjTdU4cjUWuE/X2XVLczrFxcVUU1PjoZzZbBP/4TvuvHDn1ywLCoK6x+VX+WTxhPHaiO+8851QooEDB/p+verf9bnafJWLMdzpnW1m1KhRoZvf7MrLx19auDyy40c27C2vFu8MC9nde++99OGHHwr1+cGDB9NZZ51FN954o1TILjeLdwDCC+wcBI2Xi6E4Ld79xN3iHUQdjOcgDoR18Q7cEef5qkTB3kIpWGfGE088IT5WTJkyRXwAAAAAAAAAAIB8IW/eeQcAAAAAAAAAAPIVLN4BAAAAAAAAAIB8XLx/+eWXSuFef/11igf57ZIgfuUEIMz9Lez9MDv5g2s5EB2C7hPZdSUXjKuvsI9r2SCqrhajPB/6U36z+UjFLZrbeUw7N5FIeI7Dab5BBBfv48ePp3/84x+mx3fv3k1XXHEFnXLKKRQH8t0lQdzKCUCY+1vY+2G28gfXciAqBN0nsu1KLghXX2Ef17JBVF0thmE+rMmhW0Or+UjFLZrbeUw7d/78+Z7jcJpvkFtcqc2zmwd2vzZ9+nR6+OGHqXPnzqljn332GZ177rm0fPlymjx5Mr399tsUFdyrzUfXJYEz4lLOeAN14rD3t7D3Q/v8+aHe69W9DtTmQfYIus+6df3pXzrezw37uJYNoupqMffzIbs3TOzd48LO/ZmvzOYjFbdobucx7dwRI0ZQeXm5pzic5jto4jxflQTlKm7Tpk100UUX0auvvkrDhw+np59+mr71rW/RX/7yF7r22mvFnfdbb72VbrrppkhdFMFVHACwcxA8YXC9g8U7iAMYz0EcgKu4/CLO81WJgr25emy+Z8+e9K9//YseeughcQd+0qRJVFJSQj/5yU+oqKiIFi5cSDfffDMmCgAAAAAAAAAAwAc8+Xm//PLLhVACv9/+wQcfUO/evem9994TC3gAAAAAAAAAAADk2FVcU1MT3XjjjfSzn/1MvPN+xBFH0IYNG+jYY48V77tHn1wqcMrS9lupVTW8PpzVOc3HkslEQPXmpj2y3YZBpBdmxfFsqAdHXX03SVVVleLjvA3D3Pbe82elZquidKsP4zS89v+aNWuyqqbrRMHXqdpvMOrAbuYir/GHMU636bfMizwGVFZWmIwFLlNKJmjJklJKJJp8KrNsHle9BlCLu+Vcq/9VvqumYzcOO8uzdTxm10HOrqOswxnzoDIOq9Z1FGmuj2qTOVbeXvI+am2f1mrvq1evplWrVomtfk7SlOCNWy0Mh9fO8Utt3s08YxeH0/k6SJV9f7Abj+zCR9RVHC/W7777bpowYQItW7ZMPCr/+9//Xogm8Pvv999/P0WZXCpwytL2W6lVNbw+nNU52rGlS5cGUm9u2iPbbRhEemFWHM+GenDU1Xc5joaGRvFx2oZhbns/8melZquidKsP4zS89j8/JZZNNV0nCr5O1X6DUAd2Mxd5jT+McbpNXz8v8hhQUVEpHQvcwvEOGzac5syZ60uZZfO46jWAatzauVb/q3xXTcduHHaaZ6t4zK6DnF5HWYUz5kFlHFat6yiir4+6ujrTY2ZjmEqbqai979q1i1auXCm2+jlJU4I3brUwHF47xy+1eTfzjF0cTufrIFX2/cBuPLILn2tcCdZ17dpVGNv1119Pv/rVr6h165an78vKyoTaPP+icvzxx9Mbb7xB0RSs65yhQJk94ReZ+qXfSq2q4fXhyOKcFsXPmpqaAJRL3SiiZltFNYj0sq84rm7n2VAPjrr6Lv/yX5Xy0uGsDcOuNu8+fyzIYqVmq6J0qw/DOAnPYfhOA19sjRkzhgoLXT+E5ggnCr5O1X7twrsTAHIzF3mN3yu57h+ZcybPi7zlNuK2yRwLXKaUTIhFB7vvZf0h72rzsnmcFK8BbHNrONfqf7M0VdKX26z5OOwsz9bxmF0HObuOsg5nzIN5OPO4VPMTBb6pj2SS+vfrS4Wt2+ns3Ky95H3UrM1KRvS2VXvnrda/R40aJY7rleCNW23e4rUSw+f4pTbvZp6xi8PpfO1VZT94wbqkzXhkFz6CavODBg2imTNn0tFHHy09zgt7fg/+8ccfF4/XRwWozQMAOwfBEwb1XqjNgziA8RzEAajN5xdxnq9KFOzNlWDdRx99JBTnzejYsSP97W9/o2nTprmJHgAAAAAAAAAAAH64ijP6fa+sZEGIdM444ww30QMAAAAAAAAAAECH6xf9tm7dSldeeaUQ/OnTpw8NGzYsdYzdxvFd9yVLllAUqamtdqFmGjT5pA4aBvxUzQVqpCu/ypWS/VTFdeoBIdftGrTHhrDgXmU29wq1uSO3ZfdDdT69L7PyemnpYmHv+rGBxwPez8fdKf+qKEk7LZN8XPKnr3qJO4rXBW483WSLqNRhUMRlDgoPcZ7TQJYX73ynnRXlH3zwQfH++7777ptmeAceeCD973//o6effpqiSI8ePS0VBWtyrIAdNtXDKOKnai5Qw6j8KlNK9lMV10xFNqzt6jS/UYXL5VZlNtcKtbkkl2U3U/B26+GEP6y8znoDbO/6sYHHgw4dOoin+dwo/6ooSTstk9m45Edf9RJ3FK8LVPOZi/JEpQ6DIi5zUJiI85wG3ONKsI7F6B566CF69tln6ZxzzqHbb79dqM7rxelOPfVUqqioEG7koiZY9+Tr79Ko0ftYqLa2CUhR3Yp8UgcNA16UI3OtZhxV4Zd05VdOJ1Mp2U9VXKceEHLdrkF7bAgLSeqd2Kysou5FgT2fBOu8lt2bAJAfqvPpfZkX5/X19TRx4kRRHm1sYPvncYGf6uObA86Vf1WUpJ2WSa5M7E9f9RK3/fgYPsE6N55uouhpJIpEdw6KqmCdn3NaPgHBugAW70OHDhV311999VXxv2zxzgv8Z555hjZs2EBRAWrzAMDOQfCEQb03aot3r8T5YijOYDwHcSCqi3cgJ87zVYmCvbl6bJ7vku23336WYdq1a0c7d+50Ez0AAAAAAAAAAAC8Lt579eolVZfXs3LlSvEeBwAAAAAAAAAAAHKweJ88eTL9+9//Tr2jZuTTTz+l2bNn05QpUyjaBKU8GnZF07DnL3tl0BTRmxWR/Y07//FDoTpfCEO5VRW6s5EeiJ6KsZ/tme55wv/4Qf7irx3C5pz2UwDyRTk/Gdn+72rxfvPNN4v324844gihKK+91/7ZZ5/RY489Rscee6x4bP66666jKBOU8mjYFU3Dnr9slkFTROet33HnO34oVOcLYSi3qkJ3NtID0VMx9rM9jZ4n/I4f5C9+2yFszlk/BSBflPOrI9z/XQnWMSxW98Mf/pB27Ngh/udoWCSCt126dKF//vOfwtd7lMgUrEtXHvVPECPsiqZhz1/2ysB33HnhPmHCBCooKMyj+jEnWDvP77ozJwzlVlXo9it/5nGGQQAo3wXrjCrG3gWA/LSRdM8TmZ4l8q89ckX+Cdb5a4ewOaf9NJxAsC73+Kmcnx3BumQo+39gavN6f+9PPvkkffDBB+J7165dhf/3Cy+8kHr37k1RA2rzAMDOQfCE4WIo3xfvRuKs3htnMJ6DOIDFe34R5/mqRMHeWntJoGfPnvSzn/3MSxQAAAAAAAAAAAAI4p13AAAAAAAAAAAAZA+lO+9PPfWU6wTOO+881+cCAAAAAAAAAABAcfF+wQUXpL1DoonTWaGFieLinUXKSksXU1FREQ0aNMggZJCkanabUVBAxcXFVFZWRuPHj6eamhqJqEezGAKH4+O85f8TiSTV19dRv379RHhN6ZBFEzicN/EEowCDUXSvWYCN81xbW+syrXCKPJjlkW1xyZIloj25vrW2YCGW+vp6IUantR+H1/aPHz+BysqWUt++fcX/RUX9RJh161rO0UtGsL2rtaFq/bWIxWTGaxaH97ZhG1m+fDkdNJ5F+lql2TFvjTIZXG4+xnXMTJgwkZYuXWIIV0D9+hWJemS7b+lX6X1Elu9md31LUu2Qfn56PRn7pJYHzmNz3ySpiF66KI8xTPpxjlPrQ5yG1p/ZPnhY5CT1NiLLl7aPy5VIJGjjxk2033770sqVK2nq1OOptjbdHuvq6nTlJsu2Z7VXjpfz0b9/el2bl9MszvS41cI6EzySidzo9/H3efPm0eDBg6mwsFDsKy8vp+HDh9Obb75Jxx13nNjvVixH5Tw/hXhyj/UcIWtrre8bBea4bfXzGZ/Ddj5u3HhatizT3ktLl9D69evE/6yL01yXLWMDj9GysZbnKrZrjpv/Z5rHhKJUn+M+wt9bxh8SeSosbB6X9WOXNlZXVlbRp59+Qscff7zYp4mT6uPX50MbU7TxRD+3aH3TaO+JRBPNmTOXpk6dSnV1LXOuNq7xucXFA2ju3Ll0/PFTqbCQx1wS5/33v/+lXr16ibJrc5dWD1odt4ipehn7zcbhdFvgsunLr9mHSpr68mrXPWw7+jY2szNtXNPaXyuvlh99m2rzu74c7B3pueeeFR6SOBy7M+Y253Ejs0yysdK8X7Sk42Rc9As3bZ5+XZE5v2TOv/r5TjtPPl87vS5xkv9MW9Tnhe2D+1fxwMEO4zK7nkpSZWWlGI8OHTpVzDnMqFGjxJbnA56D5s+fL+qtoqJCzFF8Ds9JHF52rcTn834+Tz93sYs1Lf7ozzHm+FfWpMf+Zje2ma/j9Os52RhhDGO8DuX/S0tLxb6DDz5YbPVjI9ePZmeeBOtYlM7Iiy++SLNmzRLGN2nSpNSku2DBAnFBdfLJJ9OZZ55J559/PkVNsO53j79EPXr2oq1bt9KQIUNowIDmSYqrqqZqLX3dsEcs3rnzHnroofThhx+KizqmQ4f2qfDsP5DdEPDFwX777S+23bp1F9vOnbtQ+/bthEs93sds3bpFhNu0aWMqDqdoaWpxGP9nn+Xs+ozzfNRRR7lKyxhnGNHnkScmFqXi9uT61tqC3Z9069aVqqqqU+3HbaDtX758BR100IGiUw0cOOgbzwpJMWBr57DNa3AfUGlD1frjcF9/3ZDKlz5eszj8aJslSxbT0MGD6auKCpo48ZA0O2Zb1ZdZKzf3Ba5bRrvQ/vLL5smO4fN27dop6pHtXutXxj4iyzfbLLef1g768431ZOyTWl45j9w3GWP96M+XhTEeZ3vS+hCnofVntg++0N64cUOajcjype3jOlu2bJnIX0XFWpoyZQqtXv25CKu3x8bGxlS5ZWXQt/0777wj4t24cSMVF/dPq2uzcprFKbMru7DG8/RpauH1giw8UbG9sN1oE5Z+31dffUWdOnUSPygddthhtH79eiopKRFz0AknnEArVqwQCyNZPCqCdXyxxZOs1XlO4w6zAJDdHCFra63v69tRa1v9fLZt23Zhu7NnzxZtY7R37iNr1nwp/m/dug117dolbWxgf9KysZbnKrZrjls7n8eE8vIvU31u9+7d1KtX79T4w/bftm1b2m+//UQ/0o9d2litXWht2LCR+vTpLfq1MX7ZmK+NJ/q5ReubRnvnuhg7dqzI/+mnn542F2vnfvXVWlFGtmWuN4bP09pr3333Tc1dWj1odcz5nTjxYNOxX0XIy2wcNtoCl01ffidjgb682nUPp6dvYzM708Y1rf218mr50bepNr/ry/HMM8/Q0KFDxI9HfI23//77iTYfO/aAjDLJxkqrfqGl46Qu/MLNfG+8rjDOL7L5Vz/faefJ5mun1yVO8i+zRX1ePv30YxozejRt2bqNBgwc5KjeZPngfdwv+VqwzeavaNy4cWI/z0UMjzE8B40ePVr8uMzb1atXizURzxccfu3atWnpcv3y+Tyn8Zign7t27tyZij+qc4wKqmW1E6yr9nitaze2Wa3j9Os52RhhDGO8DuV5g+dKhudARj82XjDtCOrcubP/avP/+te/6Hvf+x699tprwvCMzJkzh0499VR6/vnnxTZqi/c5S8tp5erVGXfemyfBRqqtW4c777jznrd33vmOz0dlS8Wd9+a7QLjzjjvv/t551y/ec3XnXVu882TJ8eX7nfeWiyHceY/TnXc1FW7ceced9+jfea+trhR33lvc+vpz5/3ys3Dn3S9Uy2qvNp/M2zvvfZJb/LnzboR//RwzZozlu/DsA37VqlXi17qoAFdxAMDOQfCEwfUOXMWBOIDxHMQBuIrLL+I8X5Uo2JsrtflPPvkk9SuzGXycwwEAAAAAAAAAAMAbrhbvXbp0Ee+2W8HHORwAAAAAAAAAAABysHg/7bTT6L333qMf//jHtG5d8/trGvz/ZZddRosWLRLiLFGkppbfY7B7m4DfbeB3bhy/dRACrPKuP+a1jE7jag7D71ixcBF/zPKYfrzlfz43M53stVXze32lYmvMc3oezPJkLJuj1B2WM8o2nA80tzW/K8feLTJtJr1PBGvXdvYZfVvR3rVz8qaYm3OAnnS7yRwfM8dy93YXfRtVI8h+ny+EsVxhzFMQeLmG8Sd9/65hs4PZPBOl+cdrXv0pa9L0utrZ/mzhPn1Xi/ff/OY3tP/++9Mjjzwi1BNZNZGFF3jL///1r38VxzlcFOnRo2dKiMAMPs6qgnbhwohV3vXHvJbRaVxaGBZHYQVU/pjlUX9c/z+fa0wnm23F6bMyK29lZdPyYJYnY9mc4LScUbbhfEBraxad4veujTZj7BNB2rWdfeaDrbDAEIsa8TbIc0ALRrsxjo+ysdyt3eWDjaoQZL/PF8JYrjDmKQi8XMP4QY2P17DZwmyeidL84zWvfpS12uK62sn+bOElfVeCdczXX39Nd999N82cOZPWrFmT2j9s2DAhVnf99ddTx44dKUpognVPvv4ujRq9j0R1Uy+IkQtlUb+wUml0qyptl45KXOmq5ua+oTNVs81V2e3K6y+aMmuLIm562VTU4u38Yluk7rCcXtSJgXda1LpZcXnixIkSlVwrNX4/7dqJAnlBJAWAjIrxKoJ1+aAyn1sBILm3E6NiuJWnB3dq1NFuKz/LaT2e52udhbFcYcxTEHi5hvGQasrO2/juASDo+cpsnonS/OM1r8bz3c1XyQC9HQSBPH0Ve3O9eNezfft2sfDt2rVrpN9zh9o8ALBzEDxhUO+F2jyIAxjPQRyA2nx+Eef5qkTB3lr7kRAv2KO8aAcAAAAAAAAAAMKM58X7zp07acuWLdTU1CQ9PnjwYK9JAAAAAAAAAAAAscaVYB3z2GOP0X777ScelecFOr/rbvwMHz6c8gN1pfRcqxZqSu2VlRU5VPsMI0G1j128+afaHWwfyWX9ZDttVa8Pxv/DqpzqH7lW2bVLXzueSCSU8qlaniDKrcXpzS7UbMvc24ZfaTjzWhKd/uC274apz3vxoBKmcvidJ+ceE6Jlu7mouzDaSzTnPy9p+ZHPYMqatL22Mu9jdt6rwmGXrhbvDz/8MP3oRz8S4gKTJ0+m6dOn03nnnZfxYeG6fEBTBGQVS7swuVYt1JTaKyoqc6b2GUaCah+7ePNRtVuGE28CXsMERbbTVvX6YPw/rMqpfpJrlV279LXj8+fPV8qnanmCKLcWpxe7ULUtM28bfqXhJIzMQ0NYcdt3w9TnvXhQCVM5/M6TG48JUbLdXNRdGO0lqvOfl7T8yGcQZa1WuLYy62P68coqTK7t0pVg3T777EObN2+md999l0aPHk35grlgXYvic2LvnpCqtqYrtXOzch6zqfYZboJqH7t4g1XtDo/wi0q5/AoTFNlOW9Xrg9FuzBR0w29bqoIs2VDZtRKss0tfOz5ixAgqLy+3zadqeYIotxbnhsIeHuxCzbbMvW34lYZ6GLmHhrDitu/an5c9wTovHlTCOHb5lSfnHhOiZbu5qLvM/fkkWJdNlXkvafmRT7M4vAnWJW2vrcz7WNLGe5VV/P7YfWBq83yxM2PGDHrooYcon4DaPACwcxA8YVDvhdo8iAMYz0EcyKfFO4j3fFWiYG+uHpvnRxzMBOoAAAAAAAAAAADgL64W7+effz698cYbQmkeAAAAAAAAAAAAIVy833LLLXTIIYfQ1KlTacGCBbRjxw5fM/X0008LwbuDDjqI+vbtS23atBGPsx966KH0m9/8xjK9efPm0bRp06h3797UoUMHGjNmDN18882+51FN/Vl+jpqCoZ1CqyxNVaVS83OdqSTaK63bq8yqx+U2f+n14Vz51b1ypF9pqatjytXJnaSXpOqqSqqtrfGhzbyG8aJerJq2U6XsMHkPcNvfg7Zrq3xpx1TbRK7q7lahVlVFXnbcb1VeLtPcuXPF1iqs/2V1q2it1pflfdON94SW+DK9p5idH+T47mYctjvfeoxLL7ebedtsPA9y3PJDidnf/NmP7X6NkX5exzi7rvReV26uOdXjDrYsRjtX93CgMg4a5yHj1mpsduKZRD9mm43fKvOBmzAq845VGKvwsrLz99WrV4uPrIzWY2TSUT9yrx7vt01njjPqayQfFu/t2rWjl19+md5//3065phjxMK6VatWGZ/Wrd25kWc1+3/84x+0d+9eIXxz9tln08EHH0wff/wx3XTTTTR+/HghImDkvvvuEz8ozJ49m/bff3865ZRTaOvWrXTXXXeJ8zds2EB+oaL+bHaOioKhnUKrLE1VpVKrc52oJKoordupzDqJy23+9PXhRvnVrXKkX2k5UceUqZM7SU+Lq7Fxt6V3BdXyeQnjRb1YNW2nStnGOHOpeuu2vwdt11b50o6pKsuaqbq7VahVVZGXHfdblZfLNHbsWLG1Cut3Wd0qWqv2ZVnftLJBu7FP5j3F7Pwgx3c347Dd+XZjnL7cbuZts/E8yHHL6XjuJA632I3tfo2Rfl7HOL2u9FpXbq45ncQdZFmMdq5yjeBkHDTOQ8at1djsxDOJfsw2G79V5gM3YVTmHaswVuFlZefvu3btEh9ZGa3GyGqH/citerzfNi0bZ1TXSL4I1h199NHKghBvvfWW0+jpgw8+oFGjRlHPnj3T9m/cuJFOO+00oXL/ve99j/75z3+mjpWVldHEiROpsLCQXnvtNTrxxBPFfjaMU089VRjPmWeeSS+++KJPgnWkoP6cEYOtyqE+TmuFVpmqoapSqfm5zlQS7ZXW7VVm1eNym7/0+lBtK7dpuj3fH3XMlnp2W59JqqqsJEo20YBBQ2wUo4NWmPeiXqyatlOl7DB5D3Db34O2a6t8NR87c9KBSnOImaq7W5Vb/XmMUbDOKl6/VXn5bgTPS8cdd5yYt8zC+lFWPq9FAMitorVaX5b3TTfeE1riy/SeYnZ+kOO7m3HY7nxzzxGZ5ZaFVZiDpeN5kOOWH0rM/ubPfmz3a4z08zpGNax/yu7OrznV4w62LEY7L1D2cKAyDh42vGfaPGTcWo3NTjyTGOcn2bivMh+4CaMy71iFkeXXquzaXXmG13vGMr60cLnFGJl01I/cq8f7bdPGssj7XGBq87lk4cKFwrc8L+x5Ma9xzjnn0AsvvCBU8B999NG0c9auXUvDhw8XF0ufffaZeJReBtTmAYCdg+AJg3ov1OZBHMB4DuIA1ObzizjPVyVBqc3nEu1RfH50X2P37t00a9Ys8X369OkZ5wwZMoSOOOII8f2VV17JWl4BAAAAAAAAAAA/iNTiffv27XTbbbeJ7/wovAYLHvDj8Qy/2y5D28+P1wMAAAAAAAAAAFFCSVHuoosuEo+hsPBbUVGR+F8FPuexxx5znbk5c+bQM888Ix53r6+vp0WLFokF/AknnEB33313KtyaNWvEtnv37tRF8rg7M2jQoLSwAAAAAAAAAABAXt15f+KJJ8SHldv1/6t8vPDpp5/Sk08+STNnzhQLeV6482PxHC+/m67B+5lOnTqZxtW5c+fUe+127Ni+jXZs20aNDV8L9xMsdqK5QuAfEpYuXUyJRFNqX/onkXGO2jG7j5tzs51eGD9B1JvxeNjrSjV/XsuhP7/5O/cT4z7r7/bxp8epetxZm3EcS5aY93P5cbsy+WUnZvHY1U/QfcNp+lpdJmjVqlXiw9+1ffxElfa/2Xn6MFo8K1eulMbV1NQkjVMlLZXwsvw4idcuHc4/z4O8tcuPedrWtmPdP/yyOz/tMZcf1XI7nU+c1lN6Poxjbo3uexW7nqusyEjL+XjmZvy2K6v79k/Pv+o849zGrcubrXk2bB+/rzPd9qsE1dXW+Di2qZfLbk6wmnvczH1O8hCWj5P8cRhvY2LSB9t0Yo/+jocqKAnWseAbwwp5/M659r8K/L65V/bs2UMVFRX073//m+68805xR5/fXWfhOobvzn//+98X+dOU+4ywiN0ll1xCo0ePFh3FSrBO4+zzf0SXXHUDbdmymfr16y8q9ZMVy2nAoMFUWVlJBx54YEYcdXW11L17j9Q5qsfscHNuttMLI0HUm/F42OtKNX+pcJs3Ud8+vamgVRtHwi/6dBj+zoM19zn9PqvvKvnTx6kPb3XcaZstX76cBg8eLMYdWT+XHZeV3yoPbjGLx65+VONxk7bT9CcO6ZH6zk9Daa89dezYkYYNGyb28VNe/MQV/y/DGEaLR1NzNcZVWloqXp/Sx8mCdaw+269fP8u0rNK1yo9dGZyks2DBAtp3332F6Ko295nlR7ZvydrNtrZj1T/8sjszwj6OGlEtt9P5RDVdY1tp+TCOud26daetmzcSFRRSQ+Nusa99+3ZpaTkdz+zGOtW8e6kHPfr89+3bR2mecWPjVuV1PM9GxM6zfZ3ptl/xwr1rly60bft26te/2DycYrvr9530rf08zQmyucfL3OckD2HBSf44bM3u9q7HRD/7moo9+j0eHjmmxX7zRm2e3ciVlJQIWX1ehHfo0EG4huN34Pmx+c2bmytP5gP+6quvFh1o8eLFlov3VxZ8RJ06d6E2bdsI3/DF38j6c1U17Wmk5R+voPHjJ5q6HGE/k9o56sfscHNuttMLI0HUm/F42OtKNX/N4foXF1Ni7x4Xqq36dCgVV21NTdo+6+9q+WuJs0DxuLM2419Cy8qW0vjxctdC8uOZ5bfOg1vM4rGrH9V43KTtLH29mqrMZYxbVzccD2/5f2NcMndzvHhn8VM7Fz5W6Vrlx61rOVl8qq7lzPY1q/da2451//DL7kxLHPJx1IhquZ3OJ2rpGttKy0fGmFtVRUVFfcR4rvl6H2Bwn+V8PLMb61Tz7qUeyCT/BYrzjHMbty6vs3k2Onae7etMd/2KbaC2qoL6DxxsmLPdjm0t+0pG9PY0J5i5iXM79znJQ1hwkj8O+/LC5R7GRD/7moo9+jseHj7S2t4iuXhnDjjgAPrkk0/EnYhJkybRihUrUr8W8wJc9t47L9x5AX/WWWcJl3Iy4CoOANg5CJ4wuN7RFu9wFQfyGYznIA4EaedhmK/iRpznq5J8dBWnf7d93bp1YrvPPvuIR04YfjxFhrZ/woQJWcsnAAAAAAAAAADgB5FbvPNj7B999JH4zu8fMG3btqWTTjop9f67EX5H/7333hPfTz/99KzmFwAAAAAAAAAAyLvFOyvMP/300+JxRiMsGHD22WdTY2MjHXbYYTR27NjUsRtuuEE8KvP444/T7NmzU/tZDOLiiy8Wao9nnnkmjRkzJmtlAQAAAAAAAAAAsubnPZvwo/A/+MEP6NJLL6Xx48cLYbrdu3cLFdGlS5cK0R5W3H3uuefSzuPH4e+9917xbvu0adPoqKOOor59+9LChQuptrZWPFr/l7/8JWflAgAAAAAAAAAA8mbxvv/++9Ovf/1rsehmf71lZWXCVVzPnj2Fyu4ZZ5xBF154oVAINvKzn/1M3I3nRfyHH35IO3fuFO5DbrzxRvGRCdkBAAAAAAAAAABhJ3SL9z59+tBNN93k+vwpU6aIDwAAAAAAAAAAkC94Xrzz3e0tW7aId8pl8J1vAAAAAAAAAAAA5GDx/thjj4nH01etWmUahgXk9u7d6zYJAAAAAAAAAAAAuFWbf/jhh+lHP/oRffHFFzR58mSaPn06nXfeeRmfH/7wh/7nGDgkSdXVVWIbTPhsx+cHSaqqqhQfeb6a85xMJnzMu3k9cDpLlpSKbXo4s++KKabFC0C4SCaT9Pnnn4stiEIdy8YgqzEq85j5mBrGeSIKWNVbS53X1dU6nFOs2tJufjG3E+s51YkNZMNezNKw6wfyeGRlN5/7veQvSjitS5XjIErE8zog6dmGXS3e77//furduzd9/PHH9NZbb9HMmTOFizbZB+SW6upq6tmzl9gGET7b8fkB56WhoVF8ZPnS8szeDfzKu1U9cDrDhg0XW304s++q6OMFIGzwj7/9+/cXWxD+OpaNQVZjlOyY2ZgaxnkiCljVm3asrGwpde/eg2oczClWbWk3v1jZidWc6sQGsmEvZmnY9QOzeGRlN5v7veQvSjitS5XjIFrE8Tqg2gcbLki6+Lmjffv2NGPGDHrooYcon9i2bRt169aN5patoU4SZXquqsTe3VTYuq14JSA6v/BU04ABA7i5Awif7fj8uvPOv3qRcEWYma/mPBcXF1NNTY1PeTevB/7VnSdvdnfIdtUSjky+q+UlPV713+miaecgSpSM6CXsjCfskSNH5sTOOP2GhgYxn+Wrnevr+P0vN3mNTTIGJS3GqMxj5mNqGOeJKGBVb83H+MK4trqSigcOtphf5OfK27LAZn4xtxPrOdWJDWTDXszSsOsH6tcT5nN/Lq7VcoHTujQ/HuR1C89XIBjMrgMWlW+k/CVpaeMq9uZq8T5s2DA64YQTxOPz+UR+Lt4BcAbsHARNGC6G4rB415PfF0PADIznIA5g8Z5fxHm+KlGwN1ePzZ9//vn0xhtvCKV5AAAAAAAAAAAABIurxfstt9xChxxyCE2dOpUWLFhAO3bs8D9nAAAAAAAAAAAAcO8qrl27dqnHVI455hjTcHAVBwAAAAAAAAAA5GjxPmnSJLw7BQAAAAAAAAAAhHnx/vbbb/ufEwAAAAAAAAAAAPj3zjsAAAAAAAAAAABCfuddD/uqW7ZsmXCz1rVrVxo3blzKhygAAAAAAAAAAAByuHj/4osv6Mc//jG9+eabGceOO+44+vOf/0wjR470mj8AAAAAAAAAACD2uFq8V1ZW0pFHHknr1q2jMWPG0OTJk6l///5UV1cnXMfNmzdPiNp9+OGHNGjQIP9zDQAAAAAAAAAAxAhXi/fbb79dLNz57vqll16aoTz/yCOPiLvyv/rVr+jRRx/1K68AAAAAAAAAAEAscbV4/+9//0unnHIKXXbZZdLjvKB//fXX6Y033vCaPwAAAAAAAAAAIPa4Upvnu+4HHHCAZRg+vn79erf5AgAAAAAAAAAAgJfFe58+fejTTz+1DMPHORwAAAAAAAAAAABysHj/9re/Ta+++io99thj0uN///vf6bXXXqMTTjjBY/YAAAAAAAAAAADg6p33W2+9VSzOL7nkErr//vvpqKOOoqKiIqqvrxdq85988gn17t1bhAMAAAAAAAAAAEAOFu+DBw+md999VwjWvf3222KxrueYY46hhx9+GG7iAAAAAAAAAACAXC3emdGjR9Obb74pfL4vW7aMtm3bRl27dqVx48Zh0Q4AAAAAAAAAAOR68X7sscfSEUccQXfccYdYqGOxDgAAAAAAAAAAhEyw7oMPPqCmpib/cwMAAAAAAAAAAAB/Fu9jxoyhtWvXujkVAAAAAAAAAAAA2Vi8/9///R/9+9//tvX1DgAAAAAAAAAAgBwt3ocPH05HH300HXbYYXTdddfR888/T++8845wE2f8RJOkUpjq6irFsCA3oI2CIx/q1q4MSaqqqhSfaJXTSdsYw8rOVYnPLIx7O0kmk/T555+LLQDB4cZG7ceO6I+PUUZtXIvm+O4nzfWSTCZ8sNegbT7q8ecPXudm73N7MvZt5Wrxzgv3N954g3bs2EH33nsvnXvuuULEjl3EGT9RpKa2xjZMdXU19ezZS2xBOEEbBUc+1K1dGXh/Q0Oj+ESpnE7axhhWdq5KfGZhvNjJF198Qf379xdbAILCjY2qjB1RHx+jjOq4FsXx3U+0elm6dKlnew3a5qMefz7hdW72en412ooKki5++rjtttuooKBAKeytt95KUYHd3XXr1o3mln1Jnbp0zTjOVZXYu5sKW7clLj4bzoABA7gac5JfoPLrHNrIKel2XpDHdWtXBr4zw7/uEg0cODBC5XTSNsawsnNV4jMLI99fMqKXfSmSSTG5jxw5Unm+cQLH39DQQO3btw8k/rCxqHxjrrMQUtyMZfZjR1jGR7XxPN9QG9eiOb77SXO9FBcXU01NjUd7DdrmreP3bufm8avMV3HC69yscr71fJUMzfgaBCr25mrxnq+0LN7XUKcuXTKOx3MSBHEDdg6CJgwXQ1i8gziA8RzEgSDtPAzzVdyI83xVomBvrh6bBwAAAAAAAAAAQPbA4h0AAAAAAAAAAMjHxXthYSG1atXK9tO6dWuKJk6VlgEAAAAA7MA1RW7rHPXvDdQlALnG1ep68uTJ0ndKtm7dKuT/d+7cSQcddBB1796doqo2P+obwTq9qmFxMYsjAAAAAAA4R39NMWAAC6WBoDGqU6P+3YO6BCCii/e3337b9NiuXbvohhtuoNmzZ9PcuXMpihT3L059ZzVDTdUQ0n4AAAAAcIv+mgLkps5R/+5BXQKQh++8d+zYkR544AGh2n7ddddRNNE/VVDwzS+KUGkFAAAAgBdwTZHbOkf9ewN1CUDeCtZNmjSJZs2aFVT0AAAAAAAAAABAbAhs8b5+/XrasWNHUNEDAAAAAAAAAACxwffFeyKRoJkzZ9Jzzz1H48aN8zt6AAAAAAAAAAAgdrgSrBs+fLh0/969e2ndunW0Z88eatOmDf3mN7/xmj8AAAAAAAAAACD2tHZ7d13mKo4X7AcccAAdcsgh9NOf/pT2339/P/IIAAAAAAAAAADEGleL96+++sr/nAAAAAAAAAAAACC7gnUAAAAAAAAAAADI4Z13jd27d9O8efNo5cqVtHPnTvrFL34h9jc0NNC2bduod+/eVFiI3wcAAAAAAAAAAAAvuF5Zv/rqqzR48GA65ZRT6Nprr6XbbrstdWz58uXUv39/evbZZz1lDgAAAAAAAAAAAC4X7//73//orLPOonbt2tEf//hHmj59etrxQw89lEaOHEkvvfSS47hZqX7+/Pl03XXXCeG77t27CyG8fv360amnnkqzZs2yPJ+fBJg2bZq469+hQwcaM2YM3XzzzSHzOZ+k6uoqsU3/DtwRVB1mxptMJmjJklKxDTbtfAX1BQCI4tgQ9vwB4DeweRA2YJOuF+933HGHWFQvWbJEqMqPGjUqI8zBBx9MH330keO433nnHZoyZQrdc889VFVVRUceeSSdccYZ1KdPH3rttdfo5JNPpksvvZSSyczB5L777qOpU6fS7NmzhdI9PxWwdetWuuuuu0R+NmzYQGGgurqaevbsJbb678AdQdWhLN6lS5fSsGHDxTbItPMV1BcAIIpjQ9jzB4DfwOZB2IBNeli8f/DBB/Sd73xH3N02Y9CgQVRXV+c4bn5H/swzz6QFCxZQbW0t/ec//6HnnnuOVqxYIR7Db9WqFf31r3+lmTNnpp1XVlZG11xzjTjOd+f5R4Dnn3+eysvL6bjjjqNVq1bRZZddRmFgwIABtGnTRrHVfwfuCKoOZfFOmDCB1qz5UmyDTDtfQX0BAKI4NoQ9fwD4DWwehA3YpIfFe2NjI3Xt2tUyzJYtW1yJ1R177LH04osv0qRJkzKOffe736ULLrhAfH/qqafSjv3mN78Rd+MvvPBCOvHEE1P7O3bsSI899pjICz/Gz+J6uaeABgwYKLbp34E7gqrDzHgLCgpp4sSDxTbYtPMV1BcAIIpjQ9jzB4DfwOZB2IBNul68Dx8+nBYvXmwZZtGiReJ9c78ZP3682FZWVqap3mvvwhvfv2eGDBlCRxxxhPj+yiuv+J4nAAAAAAAAAAAgdIt3fqydResef/xx6XF+X/3jjz8Wd8r95vPPPxdbVrPXWL16Ne3atUt853fbZWj7+fF6AAAAAAAAAAAg7xfvrAS/77770owZM4RAHKvDM9dff7143P3nP/85jRs3TojZ+Qm/Q//EE0+kfkDQWLNmjdiyiF6XLl1M38HXh7Vix/attGPbNmpsaBCP4qd/ElRTVSm2/KmqrBCfRKKJqlP7jedkxqGdx9/53CVLFlNT0960/VbnV5vkgbcVa9dSaemH4n/7vOTbR183mXVtdp7WBpl11hyf1r68raxYSx9++AEtXvwB7d27N9V2+nBqduC2TLn+yPKTbpP6uuC6kddt2MvpdzsZbTEM5VXJQxjymV+fRCIhfnTmrVmYpqYmmjNnjtjmOr/e7CFzTJafH1c7Uy13Szjz+cppevlc51bXZ5nH5POUH+Ojqv1H6dMyxxvnNPPrrXwodzjnDW0/zxX64/o5RB+GNcD4o4/Hbr7hsLLznOYpWp9ETvquCgVJ1ZAGNm/eLBbnLArHjZOKsKCAzjnnHPrzn/9MPXr0IL/gRdIJJ5wgfigYO3YslZaWUtu2bcWxZ555hr7//e8LAQNWqJfx6KOP0iWXXEKjR48Wxidj27Zt1K1bt9T/F/7karrop9ek/ueqqq+tpm49etHWrVvEvoaGxtS5HPeWLZupX7+WpwJk1NXVps5r374drVu3ngYPHkzLypbR0GFDU/vN4uHzu3fvIdIy5oG1CFavXiVeFWhs3E0HHnggxQl93XD9GevarE6XL18u2qCioiKtzrT4ePDh9uUtaz6sW1dPPXr0pPr6dXTMMUeLtjus5LBUOBU7cFumoBEDSNMeKmjVRvRnlfwYbVJfZ+8vep/GjR+XUbcq8UYJu/wbbZHJdXlV6jyIdpk4xL+5wQsNDQ3Uvn37rKfLPyIXFRVRfX09DRs2TBqGRVv5R/LPPvuMJk+e7DnNJWub+6ZXnNqDbEyWnR/1/u8W1XLrw2nXDHZjqmw8l43V+Vjn+vHWeH0mOyabp/wYH1XtP0ror4s0/SttTjO73gq63HbXLfkwX5nNG9p+XhfxU8bacf0cwjcwtTC9evVKaYJp8djNN5yG9oSz/jynecr2fOWFXPXdI8cUB7d419i4caN4/33Tpk2iE7Nvdm4wv+G7/Cw8x0b33nvvicFWw+/F+ysLllGnzl2pTdu21LZd84DEiF+T9jZSff16Kh7IIh5E1d+kVzxgANXW1IitvbhHMnXegIEDRbxlZUtp3LjxIg5tv3k8Saqprv4mrfQ88P5EIknr1tfThAkTdcJqcUFfNwUZdW1Wp/xLGrfB+PETDHXWHF//4mLRNrzl+Grr6ojnh/HjJ9JHH5WJtqurrU2FU7MDt2UKlmY7302FrduaTIKy/KTbpL7O+vXvT8uWlUnqViXeKGGXf6MtUgjKq1Ln/rdLyYjmi4dcwnauLd79vthTSfuLL76gkSNHmqbNdyr4x2r2luJG/NXIovKN5A9O7SFzTJafH/X+7xbVcreE064Z7MdU2XieOVbnZ50nLa7PMo/J5yk/xkdV+48SLddFvNXPaebXW8GW2/66JdrzldW8oe0fMWKE8LClHdfPIfy/Foa3DLv51uKxm284De21Zf15TvOU/fnKC7npu4ePNPfk5tviPRtceeWV9MADD4g7+WxcmmidBvt/P/XUU8Vj8/xEgAz2AX/11VeLX4DMxPa0xfvcsjXUSfL4fZCDAwBhAXYOgibui/dcEI6LIZBtMJ6DOBCHxXuciPN8VaJgb6G/Lcu+23nhzgtzfh/DuHBnhg4dmnJPt337dmk8mjq9FhYAAAAAAAAAAIgKrVUDXnTRRY4j51+/+FF3t7AA3h/+8AdxN5wX7mZK8vvss494B4Pfx+D3K4455piMMLyfmTBhguv8AAAAAAAAAAAAoV68ayrvqot2foTFy+L9hhtuoN///vfNj7HPnSvepTeDhetOOukkeuGFF8T778bF+9q1a8V78szpp59O4SFJ1dXV4l19puU7Hm0LH81tVczveNXUoJ3yEn1/LLA5phrW2K/dxqP2bnFmePk+TRtkoPaeoq9jj9N8U8a7c4z+PTqVd8SNcUTxEeGo5x9kC3d9LP9xOp7ajceoZ3eg3ryO7dmeC/Jv7kn6cP0UXpQfm1+0aJHSZ+bMmTR8+HBPmbrlllvo7rvvFo/K2y3c9Yt9Njj2PT979uzUfr4bf/HFFwtFfHYvN2bMGAoLbCg9e/YSW/13ED609lm6dCnaKU+x6oPGY6ph7c5zkqab/JvtY0Vg/gQx9riNjy8c+vfvL7b678ZjqnFEkajnH2QHXC/IcTqeehmfgTmoN+9je7bngnybe6p9uH4KM74J1m3YsIFuv/12oeq+e/duOvLII8UCvKSkxFE8r776Kn3nO98R3/kx+f33318arnfv3nTPPfdIRel4EX/UUUdR3759aeHChVRbWyserX/33XfFeWZkX7AOd96jQ3zuvMdX4Ah33rN1510myJLtO+9hFKwL8u5HnAWA8g/1sSFe4znuvIeD7Ndb2AXrcOc92/NVMrJ33lXszfPine9s8yL63nvvFWJxvNi+66676JRTTnEVHz+ef+GFF9qGYz/mX331Vcb+efPmibx8+OGHtHPnTuEL9ayzzqIbb7yRukgW5HqgNg8A7BwETxjUe8O4eA8SLN7jCcZzEAfCvngHzojzfFWiYG/K77wb4cfQH3nkEbrjjjuovr5e3MG5//776fzzz/fkk/aCCy4QH7dMmTJFfAAAAAAAAAAAgHzB1eKdheH4vXR+xILvVP/2t7+lK664QtzBAAAAAAAAAAAAQA4X72+//Tb9/Oc/F27XWOGdfbDfdNNNQlgOAAAAAAAAAAAAwaD8fPuJJ55Ixx13nFDb5kfjP//8c/rd736HhbsrWBihipLJhNjy/1HLe0ue7f4329dyrKqqUnzM6iGRaBIeBHibG8zyb1WuqJOkmlCUzd4+VOPx3lZO8uIm3/lkT/lUFuCOzLnBSf8xG3PV4rCzv7jZZ1jGcxBt4tZvAAgnyoJ1/B47i0AMHTpUKLcrRV5QQLNmzaKokC3BOh782CXBp59+Qvvttz9t2rSRBgxoVn0OO1retTzb/S87xxjf1183iO8dOrSX1gMv3MeOHUsrVqygE044IUslTc+jLP9W5YoybOc1VWupR6++tHnzppyWTcU+VOPx2lZO8uIm3/lkT3ZlCYMAEATrgkU2NzjpP2ZjrkocdvaXT30tSuM5iDZh7jcQrMsvIFjn4+LdKdyBWNguKmRPbT7KbsfcuFaxdt+S7rYqsx74jvucOXPp+OOnUmFhK8o+ZvkPj2sJP2m280aqq19PA0zaJIu5sbUP1Xi8t5WTvLjJdz7Zk3VZwnAxhMV70GTODU76j9mYqxaHXV/Kp74WpfEcRJvw9hss3vMLLN59WryvXbuW3MAu3aICXMUBADsHwROGiyEs3kEcwHgO4gAW7/lFnOerEj9dxUVpEQ4AAAAAAAAAAOQT7h2yAwAAAAAAAAAAICtg8Z5zRc18TSsMqCjhq5wXVbJVDjsFaKceCCik7ZMNLxFhK5vf+dHSkcfH+9mTieLbXCBSyMYJN2Oy2fdg8uws/qDGCL/KHKU50F3d+59nlXjDUF/AHf63HeYxEDRYvEuoqa0RiposzBE0nEY+phUGjOVVLX++1FO2ysHxNzQ0io8sLVk+vOQtV+2jpcvuMoNKP2xl8zs/WnxffPGF9Djv79+/v+lxEF1k44SbMdnse1B5dhJ/UGOEX2WO0hzotu79zrNKvGGoL+COINoO8xgIGmXBujjQIlj3JW3Zti1DUTMYQYxsqneGVyk0GFSU8FXOiyruyuHczu0UoJ16ILBPLzftkw0vEWErm9/5aY7vzEkHSm2LbY8veEaOHBm4uBYE67KNbJxwMyaTyfcg2tCp/Qc1RpiVv8DheE4RmgPd1b3/eVaJNwz1FW/cX5/bt51TwbpszmP5Su7nqzxRm48DUJsHAHYOgicM6r1YvIM4gPEcxAGozecXcZ6vShTsDY/NAwAAAAAAAAAAIQeLdwAAAAAAAAAAIORg8R5L5VCn6t9xUG2PUl6jgheV3nxsD6/K2v6n4VwVOx/bJbpkT9XYyfwg2+eHCrud7bmdp9ykma/9wFrVP1hPG0GSr+3lFNRDFMbwsKjVhyUfIBMs3nOsNp8LnKp/x0G1PUp5jQpeVHrzsT28KmsHkYZTVex8bJcoky1VYyfzg2yfHyrsdrbndp5yk2a+9gM7Vf8gPW0ESb62l1NQD+FDNoaHRa0+LPkAmUCwLudq87nAqfp3HFTbo5TXYPHPzr2o9OZje3hV1vZTcdmtKrY/7RIGAaB8EKxzomrsTQDIyfwg2+eHCrud7bmdp9ykGZ3xydl4bq3qH6ynjSCJTnsFS/7WQ1QF62RjeFjU6nOZDwjWWYPFuw6ozQMAOwfBg8V79onzxVCcwXgO4kBUF+9ATpznqxKozQMAAAAAAAAAANEHi3cAAAAAAAAAACDkYPGeE7yoSfuZduaxqqpK8VHLj9e8e1Ejd5OG0/Kp5sNtHoNQR8613Tr1ZOAmbb/ijAp+2FeYxhk1JVvteCKRyJnibf6r7Ua5HwU5/+S+XljZfcmSUrENW96iR/PcX1lZ4XL+t48/+h55wuBRIJf14WzOMvvuKQcu4nFyjtP4/SiXMQ73cbZcvyeTCYtreetrU82+0+3c7lpJtW+oXyPL49KO2dcNFu85wIuatJ9py441NDSKj0p+vObdixq5mzSclk81H27zGIQ6cq7t1qknAzdp+xVnVPDDvsI0zqgq2WrH58+fnzPF23xX241yPwpy/glDvbCy+7Bhw8U2bHmLGtrcX1FR6Wr+V4k/6h55wuBRIJf14XTOMvvuBTfxODnHafx+lMsYh9s49dfvS5cuNb2Wt7s21exbb+d210qqfcPJNbIsLu2YSt1AsC4ngnVe1KS9Yq0aXFXFvwQRDRw4UCE/XpVLvaiRu0mDHJZPNR9u8xiEOrJ3zO1cxW6dejKIdl1lBz/sK0zjTLMgi52SrXZ8xIgRVF5e7rvirYpgXVhUf4MTAIpyPwpy/sl9vfCdGb7AmzBhAhUUFLrOGwTrWq5tuC64DpzP/0HNT7m3M2NecutRwH19eLdz87Q1ATH9fMDIvnvpY27mGyfnOI3fj/nPGIdqnJnzVcv6ZMCAAalFb2ZftvYQotl3up1netaQXcPa9w31a2R5XM3Hzpx0oG19Y/GuA2rzAMDOQfCEQb0XavMgDmA8B3EAavP5RZznK6jNAwAAAAAAAAAAeQAW7wAAAAAAAAAAQMjB4h0AAAAAAAAAAAg5WLzn0IWZe7dlwJwWNwz+16+szcLk6iWXWLvXyJ6tu3HRI3MjlOn6R63t3bqf8mvMceuiKNONisy1Urr7KrXyyM6RSa3wvtWrV4uP/nj+u2vLN+T9QrMnf9x1madhHbfT8dq6nyQSTVRauliUST9u8H62ed7q3Rupu9dML5O8zvyfezLd01m5V7KNTXm8yoxX9fpIzR0mx8/tVFGxVmy5XbzZQT6Qj2XykxbbDNJ9G/CLpIvxNbpg8S6hprYmKy7M3LotA+bo3TD4Xb+yNguTq5dcYudeI1u27sZFj8yNkMz1j0rbu3U/pZJvv8LIwsncqMhcK+ndV6mWR3aOzBUK79u1a5f46I/nu7u2fMOsX2j25Ie7Lqs0rOJ2Ol7b9ZM5c+ZShw4dqLKyMm3c4P1s87zVuzdSda9pLJOszoKYe4zu6azcK9nhZLwyxqt6faTimkkrF7fT22+/LQQquV282EE+kI9l8hO9bQbpvg0Ea8/VeWrnUJuXqs1/SVu2bcuQ+E9Xs/TqesmpWzagRosbBnNXEu7jzmyzMLl6yaVqq7mLuGDawkk+1FwIprsRMvZv1bZ3637KL7eJbl0UZbpR4f+NrpXS3VcVKJWH4zCeI3OFot2tYEaNGpU6HpS7NqjNB4W8X2h9jPHurss8DcY8bqfjtXU/4Qt0tu2ioiIaNGiQOIOP8/6ysjIaP368CMdwHHI3Q/buW+UuztTK4mQ8z3RPZ+VeyQ9XsmZuk1Svj9TcYTY/UbCE+vbtS+vWrRPlq62t9WAH+UB+lcl/tfkW2+yT3BKY+zbg13yVNLHn6Nm5ito8Fu864CoOANg5CJ4wuN7B4h3EAYznIA7AVVx+Eef5qgSu4gAAAAAAAAAAgOiDxTsAAAAAAAAAABBysHiXUFPL7+dm622CIFXn7dWgZSqvcpVoY3xOlLbN97OKLqu/tqShdp5xv5ZXTUVWro4rVwLWFJCNH/M2kSvw8lYrT1NTcxqZ5TJTYLdTxLSzE3N1dKcKwTUKCsFeVPet7cosjGoadjZlFk82FEmt1ff1NmzV1kZb1/dVo/1r58vOkeXNWfmzo+KaS+Ves7T1+53kTwubSDhXMHZLi5aA2jjjXFXcMvW0MddsPNSO87jZrAqeOf7Kx4TmOLT+wufPnv2GOF/rZ/w9czxIrwfZmKQ+Pgetcuxnm7idZ9TsRv3aIIixI19Upc3tycu1olX/sfIUo6Lm7x+qeTELaxWPVXyZ9qu/rmMPKKtWrcrwhBKWOcyP+FXmOr/wJ86kzbjY0l+M1/zanKDudUJuM0YPKpnzXPp1uDG8bB3A39nO7MDiXUKPHj2zpkwYpOq8ihq0TOVVphJtPOZEadtqP6vo8junWhqq5xn3a3nVVGRl6rhmSsCaArLxY9YmZgq8vNXK89xzz6XVnexcfbvbKWLa2YlMFdlO5dgsnR49e1FdXV1gqvtWdmUWRjUNO5syiycbiqRmbS+zYau2Ntq6vq8a7V87X3aOXZ2olifosTKXyr1maev3O8mfFnb+/PlZK5OWpuo441RV3ArjmGs2HmrHedxkVfBly5aZ9g9ZHFp/4fP79Okrztf62bJlZRnjgbEeZGOS6vgctMqxn23idp5RtRvVa4Mgxo5sjUdBY2VPXq4VrfqPlacYFTV/v1DNi1lYq3hUyya7vmMPKCtXrszwhBKWOcyP+FXmOr/wI85qm3FR31+M1/zanKDqdcLMZoweVIzznPE63Bhetg7g72xndkCwTiJY9+Tr79Ko0ftIFEuDEMQIUnXeXt1apvIqV4kuVFB2dar2yHdJK6m+vp4mTpz4TRoq+c/cr6nksrovq8jK1XHlSsBmXcBcEVmuwMtbbksuz/jxE8QA0VJ3medqA4Zc3dypnWSqImvhzVWOZSSpuqqK+hX1ocLW7Uzs3Jvqvpmisaw90+tPTb3Y2qbM4smGIqm1+r7ehjWFallbG21d31eN9q+VR3aOd0VW93XmRAAol2rzZmnr9zOq+dPOGzFiBJWXl2dFjVhLc0NhD6VxRj4vuE49bcw1Gw+14+PGjaeysqXUt28RFRamj7/yMSF9POrfv5jmzp1D++23Pw0aNFDEnUgkad0643iQbruyMSl9jLOqt6BVjr21iTMvOWbzjF1ZnF4bBDHeRk9VWo65PXm5VrTqP2btJbt+ysYcaZ+XTBtSt3O7sjV/11/X9U5sTnl80HtCUS5VwOrzfsSvMtf5lXeVOO0F65I242JLf+Ew+mt+bU5Q9zohtxmjBxUtHdk8wudwHPrw2j79PMPhD+rfkUaPHm1ZeizedUBtHgDYOQieMKj3Qm0exAGM5yAOQG0+v4jzfFUCtXkAAAAAAAAAACD6YPEOAAAAAAAAAACEHCzeXZErtWq7dMKQh6jjR9vGtR2ilJ+w5dVv8r18+Ysb9frov/3m5xibL+Ovn/EbvYioee7I7hiiml6+jG1Q3Jejbpv+ecUIjrCO0X7ny+m8xYrqbtX73ZEv80IzWLy7oCZHatV26YQhD1FHRSnXTRxxaIco5SdsefWbfC9fPuNGvT4XSvx+4ucYmy/jr5/xs/eQHopK3UGkr4JqevkytgVRjnyoGye26ZdXjCAJ6xjtd76czlusqO5Wvd8N+TIvaECwzpVgXRuJumG2lE7tFeRzm4eo44cSebTbwb3wS9jsIgx9JVeEu3xhEAAKq2CdE3VfJ2HDLQDk5xgb7fHX7/ibx/NGqqtfTwMceQfJ9hiiml64xzZ1oLgvR9029erfvJIJo2Bd0ErzYcmX03mL79IzZur9/s9XycjMCyr2hsW7DqjNAwA7B8GDxXv2CffiHQQFxnMQB6A2n1/Eeb4qgdo8AAAAAAAAAAAQfbB4BwAAAAAAAAAAQk4oF++rVq2iBx98kC644AIaO3YstW7dWjwGc+edd9qeO2/ePJo2bRr17t2bOnToQGPGjKGbb76ZduzYQdHEXrmQFTeXLCkVWz/iA9nEqWoq2g+AMKn+Bq0m7H/8dmOIH2MMxin/yFVdog3jR64VuWFzcVDAV0/fjT0kqaqqUnyiMWa6s/lQLt4ffvhhuuKKK+jJJ5+kjz/+mJqampTOu++++2jq1Kk0e/Zs2n///emUU06hrVu30l133UUHH3wwbdiwgaKGinIhK24OGzZcbP2ID2QPp6qpaD8AwqX6G7SasN/x240hfowxGKf8I1d1iTaMH7lW5IbNxUMBXzV9N/ZQXV1NDQ2N4hOFMdOtzYdy8X7AAQfQtddeS08//TR99tln9MMf/tD2nLKyMrrmmmuoVatWNGvWLHrnnXfo+eefp/LycjruuOPE3fzLLruMogYrFm7atPEb5UI5EyZMoDVrvhRbP+ID2UNrD247lXZB+wHgDlbBra2tFdsoxBtU/HZjiB9jDMYp/8hVXaIN40e22twsHdhcdgh6zvIrfTf2MGDAAGrfvp34RGHMdGvzkVCb58fn+S78HXfcQbfccos0zDnnnEMvvPACzZgxgx599NG0Y2vXrqXhw4dTIpEQPwbwo/QyoDYPAOwcBE8Y1HuhNg/iAMZzEAegNp9fxHm+KomL2vzu3bvF3XZm+vTpGceHDBlCRxxxhPj+yiuvZD1/AAAAAAAAAACAF/Ji8b569WratWuX+M7vtsvQ9vPj9QAAAAAAAAAAQJTIi8X7mjVrxLZ79+7URfK4OzNo0KC0sAAAAAAAAAAAQFTIi8X79u3bxbZTp06mYTp37px6r92OHdu30Y5t26ixoaHZhVdVpdjyOzUtH7P9Zses40kkmnTH9WGN51kdU8mHl2N26TlJw+l5CaqqrKDKirVim15ffqXrPC9afvTtYdaWvH/JksVia0yD42iJR5aun2WyLm+NbTqycqrbkFZWc5sPsnzB1JmT/trUtNfUDszrNT0eszpMtyO/+rH3+sm0b3yi+VHp+2pxyOyb49XbNo+vpaUfij5j7FfyPiBLI/v2bp+ekzyZ92suO9cP15Ndn28Z1+3mFifXL25txO01jtv5I/36QQuXOSdnjrP2c7x5XZjP+W7qNWibNMuvvE70H31/Xbz4A6pYa7w2yrRlb2OIvIx1tTUK8Tm/juWne1kzK7O+nB1jz1lz5syhvXv3ph2ThbWKW952zsJ7/fidXrbznwzxJzaCdc888wx9//vfF2p9VVXsLy8TFrG75JJLaPTo0UJ53kqwTuPCn1xN086aTt2796AtWzZTUVE/SjbtoYJWbai+vi61v1+//mnx1NXVZhyT7dPvZ6PlvPFxRgur/87n6eMxHjNilqbbY1bnyHAa3q7+2PXD+vXrqU+fPqKttPpyUjan2OWF4fywsiVj1Zbr1q2nwYMHU0VFBR144IFpaXB8DMdjbGfZ/0HB6XTr1p22bt5IRf0HSIVfZDbrxIa0surbUF9PQZYvCKz6pOzY+4vep3Hjx0ntwKxejfGY1aHejox5keU3G3Uts++JQ3pQGNAE6+LAkrXNNuIFlb6vGofMvjnerl27pmy7sbGRunbtQrU1dXRYyWFp/UrWB8z6S7bt3S49J33Q2H+Mc0r7du1o2/ZtNHDgwLRjWrx8iVdfW03devSirVu3ZIRRmWuc5tfJ/GCVH9kxN/OH8fpBG4eWL1+eNifLxln9OVo6qvZvjN+srrIxr6ukI8uvWZ3o0a7JuL+yBtXOnTupR48eaXWtxWXVbz2VsbaGunbpQtu2b6d+/Ys914U+/DFjh1J9fT0NGzYs7Rg/yVtUVKR8bMGCBbTvvvvSW2+9RSeffHLqmCysVdwynIb3it/pGePzY76KKkeOMbffvFq8v/baa3TqqaeKx+Y3b95s6gP+6quvFu++L1682HLx/sqCj6hT5y7Upm1batuuLdVUV1PxgAHENdWiZkmp/UTGBU5Scky2r2V//+Jiqq2p+ea4Pm5jOvp4rPJglabbY1bnyHAa3uq8JFVXVYkLEV5Q8rGW+nJSNqdY54Xh/Az45sLJqi05fFnZUho/fgIVFOgfemmOj2mOx9jOsv+DIkk1VVVUVNSHClu3M1Ftldmsug1pZU1vQztbDjNWfTLzWL/+/WnZsjKpHZjXa3o8ZnWYbkdmdZotWzK37zCo93J/hNq8U1T6vlocMvvmeHnL8HG2m/p19aKv1NXWpvUreR+Q95ds27t9ek76oLH/pM8pS5cuoaK+RTTwm1cDjfGKu1p7G6m+fj0VS8cFlbnGWX6dzQ9OrnHczh/p1w/aOMR3VdPn5MxxNv0c2RxvXh+Z8cvrKivzukI68vzK60SPdk3Gx+rq66iobz9xjayvay0u637roYTJBNVWVVD/gYNN6tr9dWzvxGbh1sw4T3A9sK9y1WN8V3n+/Pl07LHH0pdffpk6JgtrFbe8/M7Ce8Xv9IzxxVlt/vCRveOxeF+xYkXqV0JegMvee+eFOy/gzzrrLOFSTgZcxQEAOwfBg8V79onzxVCcwXgO4kCQdh6G+SpuxHm+KomLq7h99tmHOnbsKL6XlpZKw2j7J0yYkNW8AQAAAAAAAAAAXsmLxXvbtm3ppJNOSr3/bmTt2rX03nvvie+nn3561vMHAAAAAAAAAABQ3BfvzA033CAelXn88cdp9uzZqf3s//3iiy8WKo9nnnkmjRkzxueUk1Rdze/wJD2dLxQw0+JRiVc1ba95BNGo0zDmySqPZrafD0ShLXL7iOPnn39uq6yqGi5b5Co/snT1+5zny2ifmf3S27ySpKqqSvHJPG48JovHOm7nc2U+kT5uCgXvqkqqZBVwVvI21CurerMQGYezise8/r1ci1jZQZhxYn9ADdRbEIRtjox6PqNCKBfvS5cupcMOOyz1mTVrltj/yCOPpO2vra1NncOPw997771ikT5t2jQ65phj6Lvf/a4QP2CBCH60/i9/+Yvvea2urqaePXuJrZfzucz6eFTiVU3bax5BNOo0jHmyyqOZ7ecDUWiLXMLCNP379xdbP8Jli1zlR5aufp/TfBntU9YvvcwrvI9VpfljPG48JovHLm6nc2U+YRw3ect1WVFRKT7Gep07d55QEGchMqt4zOrfy7WIlR2EGSf2B9RAvQVD2ObIqOczKoRSsO7tt98Wi28V1wJDhw5N2zdv3jyxiP/www+FuwqetFik7sYbb5QK2XkXrONfE6uFmzp3ipnN5xezym5NjS4elXhV0/aaRxCNOvUnT8EKHOnzSCa2nw+E0T7Cw2HDeyop1QapoOtGsC7bir5W6er3MXb5ShcAMtpnZr/0Nq/wHddmVelmF2YFFsdk6VnHbZ73OPS19GsG3vL/eu8n+nrt168fLV9WRgeNn0CFha1M4zGvfxV7MGsDKzsIM07sD6gRbL3FVbAuV3NS0PmEYF0EF++5AmrzAMDOQfCE4WIIavMgDmA8B3Egrov3fCXO81VJXNTmAQAAAAAAAACAfAaLdwAAAAAAAAAAIORg8S6huqZKqtrqViWT1VyXLCmVqL1mhBTplpYuToW1PtdtvloUYNWUvv1QjPVHlV9NkVhdHVdT6jUvm7O4nCmpO1FN9kup1U/F13S7kNuqGxVrlfyGUXHaPA/m/dh9H859efOfXCjkelORd5Vihi0F2Zft1c3VwvozdgeJX9403M6/uS5/UDhVts9lPUSlDaznLr4mrajQXxM7iyPoPEYVbXxPJBJQYs+ZrSQjaVdYvEtobNgtVW2tcamSyWquw4YNF1srOB1Ol9/B1MJanetWvVOvAKui9O2HYqxfqvwqisRO1HE1pV6zsjmNy4mSuhPVZL+UWv1UfDXahcxW3ahYq+Q3jIrTVnkw68de+nCuyxsHcqGQ60VF3g0yWwqyL9upm6uG9WPsDhKVOUA1Hjfzr9frlrDiVNk+l3aQaxv0a+7q0KEDLVu2zNIGgy5rVOrSCdr4zh6xoMSeG1upjqhdQbBOIlj3xKyF1KFjpwzVVlZlTezd41gQg3+55AGQ3dkVFBTa3HmvpPr6epo4caIIa32uW/XOFgVYPtde6dsPxVh/VPnVFInVlfo1pV7zsjmLq6UuVZTUnagm+6XUah+PuvBLul3weZm26kbFWiW/YVScNs+DeT9234dzX978F6zLhZKvUxV57wJAmbYkt1d/+rK9unmBUlh/xu4gsSqDs3jczb9JT9ct4cWpsn0u7SDXNujP3LVkyRLq27eICgu1a+KCHJTVOv4oCtZpY/2IESOovLw89Irx0RGsSzqwxfD1UajNOwRq8wDAzkHwRGXxnk/EWb03zmA8B3Egiot3YE6c56sSqM0DAAAAAAAAAADRB4t3AAAAAAAAAAAg5GDx7pgk1UgVd1UVC7OtbOhU8dZL/ryov6uE81cp3ZtycpB5y2fC2k+ylb7XPuIkbPTVf3Oh9h5WVOoiOvWVjbnTiYeSKGDlYaP5eyLRJPUSUFdX63OZo1aPQeQ3anXgF+oeePKn7wG/ic5c5YXgbB6Ld4fU1dVRD4nirqpiYbaVDZ0q3nrJn6oyuNu0/VZK96KcHGTe8pmw9pNspe+1jzgJmw/qv7lQew8rKnURlfrKxtwpC5/rccULZor8+jqcM2duhpcAVpvv3r2Hr6rzUavHIPIbtTrIZrnzre8B/4nKXOWFIG0egnWOBesaqa5+PQ3QqdA7U9/NtrKhU8VbL/nzov6uEs7PuvOqnBxk3vJZ4MgvWwiaoNL32kechM2t+q8fAkBBqr1HTbBOpS6swoRLAMjN+OvU3px4KIkCVh42muuQL4bLysrSvATwXfiaqgoqHjjYxtuNl7yEnSDyG7U68At1DzzZ7HsQrIsWdvNZuOYrt7izeajNOwRq8wDAzkHwhOFiKGqLd6/kx8UQcArGcxAHsHjPL+I8X5VAbR4AAAAAAAAAAIg+WLwDAAAAAAAAAAAhB4t3AAAAAAAAAAAg5GDxnhPgMiMs7nWqqirFR39c25fpXs/vdvPuHozzWFq6mCoqKqiyssJQFpOYkgmdOyFz12U1pi4G1V07ZdZvXIi+m7awElYXM3b5Cmu+899+86GvWM1jVuFAbglTezh3tZif83eY2gQAd2DxngPgMiM87nUaGhrFR39c22d0r+d3u/nhHozz2KFDB1q2bBlVVFSmlcUMPkdzJ2QWr+YSUeZi0IlrJ2P9xoV8cNMWVsLqYsYuX2HNd77bbz70Fat5zCocyC1hag83rhbzcf4OU5sA4BaozedEbT6uLkbC516nqop/gSUaKFz/NR/X9nGYdPd6frebd/dgzXfRl1DfvkXEJsl22VIWk5iSCbEob3YnVJARr94lYnFGHTjJd0td2uUp/wivm7Yw4EW91y/3cX6rzdvlK0i3d/6r9+aT/Ua7r9jPY9YuJ6E2n0vCZHvOXS1Gaf5Wt3PnbQK1+ewDtXlrsHjXAVdxAMDOQfCE4WIIruJAHMB4DuIAXMXlF3Ger0rgKg4AAAAAAAAAAIg+WLwDAAAAAAAAAAAhB4t3BVVKueK2lTK5uTI4q3wnEk3inHR18PS0eKuF0cJp+/xR/0zPY7oCuZNznSumG8toVHvX4tPy1NS0l2bPni3qTTvO383zq5Inp2XIVKmXtZ95HC1lN1O4V1WLD0YFVpZ/uRq/vE/YqSFb1bdT5eSwqMU6tZt8VfNV9z5gFU5FjZ2PrV69Wnz4u5NzVq1aJbaJRCLtHH0c+u8cbs6cOeI8p2+XGfNplY5VGdwo1HO+586dK7bpcWTOUfqxWG08dNMnnYy18rFBLX9u56Vs27xqHZqND1ZziVl8SarWzTE8f7KXEv4/2mOPU9zOS3bzfxjx4s1G9RonVx54/EjXXRyysd1q/NWPwbzPbP7Sh+FtU1NTKh7jPGAMq5/TVOcMfTmMc6Ix37I5zCqcrNx2c66xbuRt5GZuko+Z+jWWbA1nNfaqzV/O+p/Ta0Es3hVUKTXF7RqJsqtMmdxKGZxVvufMmSvO0auDG9PirRZGC6ft80P905hHvQK5k3PdKKYby2hUe9fi0/L010cfpbFjx4p6047zd7P8quTJaRlkKvWy9jOLQ192M4V7VbX4IFRgZflnezdrHzslfjuVfy/KyWFRi3VqN/mq5uvE+4BVOBU1dj62a9cu8eHvTs5ZuXKl2M6fPz/tHH0c+u8crnPnzmLx7lQh3phPq3SsyuBGoZ7zzeMlb/VxyOYo/VisMh666ZNOxlqzsUElf27npWzbvGodmo0PVnOJLD4ex9l7iH6O4fmTvZRUVlZGeuxxitt5yW7+DyNurs2srkmc2HLQefYjXbdxyMZ2q/FXPwbzPrP5Sx+GtzNnzkzFY5wHjGH1c5rqnKEvh3FONOZbNodZhZOV227ONdaNrI3czE1mY6Z+jSVbw1mNvSrzl9P+5/RaEIJ1loJ1zaqUxcXFQnGbt4m9e3SCGGbK5GSqDM4GMn78eBGWq75FHZwy0uL/tebhcByf1rDe1T/TFTfTFcjtftNJV2yXldXqPGMZ08vTEjeXnfM0btw4mjt3Hh1//FQqLCwUx7mzl5WVmeRXRU3UaRkyVepl7WceR0vZZWXOjC/bKu76eqdvhF/amLaP1obm6sfWKv/WYWV1rrI/2zi1s4JIq/mao+59QAtXMqK3KzV27Vd6ZtSoUWKreo7WvzhseXk5jRgxghobG6ldu3bif96vj4/Dz5s3j4YMGUKjR492JIJkzCefqy+fPh2rMrhRqOc7GHwhdNxxx4nxUotjfUH3jDlKPxbbzV/u+6STsVY+bqjlz+28lB2bt/fWkVl2+fhgNZdkpt183bKbauvWiXs6bEe8j+fWoqIiGjRoUITHHqe4nZfIZv4PY/158WYjuyaR9alceeDxw6uCet71AmKysd1q/NXO4TGY5xxtYWqcv7TvHIbno+HDh9Obb74p4uE09POAPj5tLpPNYVb1oC+HNicazzHOP2bzkd1+ff7M5kJj3bz/5SaF60o99sf0Y6a2ntJs3LiGsxp71eYvZ2sjfXqy6yMjWLzrgNo8ALBzEDxhUO+F2jyIAxjPQRyA2nx+Eef5qgRq8wAAAAAAAAAAQPTB4h0AAAAAAAAAAAg5WLwHhnfVQXOVexBewqKEni28qk/nG36okTpRWHWbj9zjRkndLg4/4nSSnpM0nSr1Oo0nunYRxjxlk7iXH4D4kYu5Kr9Iehg3vY65uR+zsXgPCD9UB42K3iD8+K2+GtXyulUFjTp+qJE6UVh1m48w4EZJ3S4OP+J0kp6TNJ0q9TqNJ6p2EcY8ZZO4lx+AOJKLuSqfqPYwbnodc8MwZkOwLjDBOu+qg+nqhxCaiQZhUUJ3j3s7d6M+Hc06MscPNVInCqtu85F7QRY3SupGVNVw/RKsk8WvmqZTpV6n8agJAIXRLsKYp/wpPwTrQByImmCdH/NfLuPPvWBd0sO46XXMDXbMVrE3LN51QG0eANg5CJ4wqPdCbR7EAYznIA5EbfEOrInzfFUCtXkAAAAAAAAAACD6YPEOAAAAAAAAAACEHCzeTbFXy5arwVspRScdh9eU550rTwethqhSFuM+J3UhK7tV3TtVN8+WSrpbrwNu0lZRKXdSblldZ5ZH1hbytjOvE/v2lP/vzSODc3uzqwu1/LfEaUyT9y1ZUiq21uVUqbeW7+nxOm03p33VrHx6TxrJlBpuIpFIqeLaKeTqj6uqt6uo7qqc4yRvqvvs0nVSXvt6dDIWmY8T1n3bLJyXec56zDLvk+7GxMw+mFkmq3GAj1dWVkj7g9nWuq7ihP04z99LSxeLOtbXnfG7+nVHVFAth7xvyecw53OJvVckqzkz/Vz7/DuvoxrFerEb/+zGOSfzF/+/evVq8ZHNfcY4ONzKlStpzpw54pi2b9WqVeLD383O5e9NTU00d+5c2rt3r4iDz+Fwxjzo/+fjfA6fq09LS08/J2nn6dNWnQOtyq4/R+X6qdrh9a3VOWbXePZrMPO8Gcct4zWY+ZxhDxbvLtQEa745JlODt1KKlsVpF15TnneqPB20GqJKWWTlUa0LWdn1YYx171TdPFsq6W69DrhJW0Wl3Em5ZXYuK4+sLWRtZ1Undu1p9r8Xjwxu7M2uLlTyr4/TmCbvGzZsuNhalVOl3vTf9fE6bTenfdWsfPpwLKSjqeHOnz8/pYprp5CrP66q3q6iuqtyjpO8qe6zS9dJee3q0clYZDVOWPVts3Be5jm7McusT7odE419UFYmq3GAj1dUVEr7g9nWqq7ihMo4z987dOhAlZWVaXVn/K563REVVMth1rdkc5ibucTOK5LVnGk81y7/Tqmrq6MeivViN/7ZjXNO5i/+f9euXeIjm/uMcXC4t956izp16iSOaft4Qc8f/m52Ln+fOXMmjR07lu655x7q3LmzWIBzOGMe9P/zcT6Hz9WnpaWnn5O08/Rpq86BVmXXn6Ny/dTT4fWt1Tlm13h2azCrvBnHLeM1mNmcoQIE60wF6zpnqAm2CGK0ESrwxcXFEjV4K6Vombq0dXhNeX7gwIEOlaeDVvCVxW+3jxzUhazsLWEy696punm2VNLdeh2wisfsXBWVcvty84hgbueZbShrC3nbmdeJfXvK/5f3QTd1qmZvdnWhlv+WMmsDtZYm/yrLg/uECROooKDQ1t6t660lTzx2tcRb4LDd7Pt1+nlm5WsJd9bkg1KT9IgRI6i8vFyo4mr7zBRy9Qq6ZmFVFej1gnXGuNyoyqueY1UGq7zbldeuHheVb3AwFpmPE9Z92ywceZjnrL0ymPdJlXEks6yZfdDOE0z6OMBhuE243o39QT+G6LfGfuLn3B0twTr7cZ7Ls2TJEioqKhL1pdUdH9N/Vxuno4TqtYS8b2l14nUuMc4VmV6RrOZMp9cHBQ7tvJHq6tfTAMXrDqvxT5/HkhG9pempzl/a3WZm1KhRqXDaucY4tDvSFRUVNGXKFBGX/u40/89hZedyvMOHD6c333yTjjnmGLEdMmSISFdbIGt50OeJ4+aF9LHHHivi0y8NOT0Oo81J2nlaHpzMm8Z60+dff85LC5fbXj/V2K6/0tve6hyzazz7NZh53ozjlvEazGzOkNmbESzedUBtHgDYOQieMKj3Qm0exAGM5yAOQG0+v4jzfFUCtXkAAAAAAAAAACD6YPEOAAAAAAAAAACEHCzeAQAAAAAAAACAkIPFe07x6rZExQ2O6vlO3Iq5zV8QRNn1S67xaj9+ph2VuMNElMrpX15VXL9liyDykv3yRakv+hVflPqOn7h1EQj8J2gXdmhLf+ogPPNNLgnTvOutrd24mgvf+IrFew7x4hJDdr7T+OxcZ/idvyDIRhr5ipn9sIu4bKcdlbjDRJTK6WdeVVy/ZYsg8pLt8kWpL/oVX5T6jp/YlTuu9ZIL7K6//Iw/rvhRB3xuWOabXBKmeddLW7txNRfG8RVq8zlVm/fqzk3FDY7q+Spu7LzmLwiykUa+Yu6WJ7F3T8DqxEG2W1xsIkrlTM+rF/VeO5dt2VSb9ysvQcdprd4bpb7oV3xR6jveSL9ucesiEPiPX25kVeLP/7aUX5/7UQdJ6p3Y7Pt4HDWCmpf8U5tPKra1vdu44NY8avGrXB9h8a4DruIAgJ2D4AmD6x24igNxAOM5iANwFZdfxHm+KoGrOAAAAAAAAAAAIPpg8Q4AAAAAAAAAAIScvFy8v/DCC3T00UdTjx49qFOnTnTQQQfR7373O9qzZ48PsSepJhC1Wy8qhJmqpXIlRbs8xAFnipTycEEo84cNv+w8irhpyzC3v5MxIX5qtnbpyo6HX3m3Gc7f6tWrxSd37e62b3jxnpIfKtfyOJJUVVUpPmbxc19fsqRUbM3j9Hsey6X3EtV8WeXRL/X3XJQ723NWrubIsNiUN/yeP4Kej4zxq6RndY7Z+en7nfTHpMPr9ejbWd4t3q+66io655xz6H//+x8deuihdMIJJ1BFRQX9/Oc/p2OPPZa+/vprT/HX1dVRjwDUbr2oEMpUS2VKinZ5iANOFSll4YJQ5g8bftl5FHHTlmFufydjQhzVbO3SlR0Pu/KuBudv165d4pOrdnfbN7x4T8kXlWtZHPx/Q0Oj+JjFz3192LDhYmsWp9/zmJ/XNH5iVWazY37WQz7OWbmaI8NiU17xe/4Iej4yxq+SntU5Zufr9zvpj9UOr9fzwc7ySrDuX//6F51++unUuXNneuedd2jChAli/4YNG8TCfcWKFXTNNdfQPffc40GwrpHq6tfTgIEDfVa79aJymKlaKldStMtDHHCmSCkPJzuWP3Xpr51HETdtGeb2t1JXDY8gS7bVbDXBunbt2lF5eblpurJ8ZTuvbtHuZDAbW/XMUbu77RtevKfkuk38UbmWx8F33vmuENFAk/GZ77jzwr35GqjARG3ebw8zfl7TZEvV3eyYF/X3XJQ723NWruZI8ziiJFjn9/wR9HxkjF8lPatzGNn5+jDvf7nRQX9MOrxety1xTseu2KnN8532xYsX05133kk333xz2rF3332XJk2aJC7U6uvrxSLdCNTmAYCdg+AJg3ov1OZBHMB4DuJAlBbvwJ44z1clcVKb519JeOHOTJ8+PeP4kUceSYMGDaLGxkZ6/fXXc5BDAAAAAAAAAADAHXmzeC8rKxPbnj170rBhw6RhDj744LSwAAAAAAAAAABAFMibxfuaNWvEdvDgwaZh+M67PqwZO7Zvox3btlFjQ0NKGbHlk6CaqkqxzTwWzCeRaKIlSxaLrbNzE1RdVSnOq/Y1zwmqqqwQH3/iTniIQ3ZuUOXO5sesDC11n1kuu3J7qedclzsoO7I7R3/c7Hv26sU+PSf157XveKuDRCIhVNB56/bcpqamjDi8xOs1f5yfOXPmiG3QNuFXOYOzxaDjdt533c8JYRg7zfurfn7I+L+ygmprqj2W2S6dzPPS69o+vFo7mueX0yst/ZAqK9Y6TMfKNvy0R7e25Nb2nLRZLm04qPLnKl7vHx7TV61aJT5Bju9+zCF87sqVK+m///2v7bxnTE8/j2eWV70/VZleE/tlA17ScP5RIW/eeb/rrrvEe+5HHHGEeL9dBh/ncMcff7wwNLN33jUu/MnVdNFPr0n9z1VVX1tN3Xr0oq1bt1C/fv0pGyxfvlz8KMGq+QceeKDyeXV1tdS9ew/ROUaPHk1btmz2Jc8cLyvdanXmNW4tn27ikJ0bVLmziVkZ9HXfvn27tHLZlVu1nsUA0rSHClq1yfo7kl7azo0d2Z2jP87IvmfDtlTL5qT+vPYdL/124pAe4kfUoqIioUFi9rSUGdq5paWl4okqfRxO4tXeebdKw0n+FixYQPvuuy999tlnNHnyZAoSp/lbsrbZbr3ipd39jNtN33U7JwRZZi95MO6T/d/wdQNL1lG79h2oX/9iV+kxVunIztPXtfF8u3I5Oa6/Tmrfrh1t275NCPmppmM15vlpj07DuQ1vdl5Ybdivc5xetzjJC89X2YTHdvYQwnTs2NHx/OgkHbdzsD4OFkVl19zszctq3jOmp5/He/XqlVbeWR98qtyfGkyuie1w0mfdpuGGI8fYj9NYvEsW768s+Ig6de5Cbdq2pbbt2qWOi1+K9jZSff16Ks6iCjf/0lNWtpTGj59ABQWFDn11V1P/4mKqramhYt+UE5NU/Y3aLcfpPe7mfLqLQ3ZuUOXOJmZlaKn7TCV4u3Kr1XNuBY68tJ0bO7I7R3+cTL5no45Uy+ak/rz2Hff9lgVZvCjkaueOGDEiQyleNV47wTo3+eO7BvPnz6fjjjuOCguDfbDNaf78EwDyMl77Gbfzvut+TgiyzF7yYNyX+X91ZSVRsomKBw1xdf0gH++s6kM2hliNl07a0ao/s8L+EirqW0QDxVOWqulYjXl+2qPTcG7Dm50XVhv25xzn1y3qecm2YJ3eS8ioUaMCuw7zMgfr4+AfvtauXUtTpkyxnPeM6enncc1tnFbeReUblPtTtek1sW3us5CGcw4f2Ts+i/cHH3yQrrjiCho3bpzpO+1XXnklPfDAA3TWWWfRCy+8kHEcavMAwM5B8IRBvddu8Z5vxFm9N85gPAdxIEg7D8N8FTfiPF+VxEltfujQoWJbyb8ym6Ad08ICAAAAAAAAAABRIG8W7+PHjxfbjRs3mgrS8XsVzIQJE7KaNwAAAAAAAAAAwAt5s3hngZJDDjlEfH/mmWcyjvN78HznvV27djRt2rQc5BAAAAAAAAAAAIj54p256aabxPa3v/0tLV26NLWf78Zffvnl4vtPf/rTNEV5AAAAAAAAAAAg7OTV4v20004TonU7duygww47jE488UQhTsfKhitWrBBK9HfccUeuswkAAAAAAAAAAMR38c788Y9/pOeee45KSkrovffeo9dff108Us934998803q0KFDrrMIAAAAAAAAAAA4ojXlIeecc474AAAAAAAAAAAA+UDe3XkHAAAAAAAAAADyDSzeAQAAAAAAAACAkIPFOwAAAAAAAAAAEHKweAcAAAAAAAAAAEIOFu8AAAAAAAAAAEDIweLdAbsbG+nvD90rtgDkK7BzEAcaGxvpzjvvFFsA8hWM5yAOwM5BnMDi3QF7du+mx//0B7EFIF+BnYM4wIv2u+66C4t3kNdgPAdxAHYO4kRe+nl3SzKZFNudO7ZLj2v7eVtQUJDVvAGQLWDnIGi2bWuT6yzQtm3bUts42PnO7fJ5DeQ3GM9BHAjSzsMwX8WNOM9X27a1oS5duljacUFSW7ECqqqqokGDBuU6GwAAAAAAAAAAYsbWrVupa9eupsexeNeRSCSopqbG9hcPAAAAAAAAAADAT3DnHQAAAAAAAAAAiDgQrAMAAAAAAAAAAEIOFu8AAAAAAAAAAEDIifXifc+ePTR//ny67rrr6JBDDqHu3btTmzZtqF+/fnTqqafSrFmzbN+Rf/LJJ2nKlCnUp08fateuHfXv35+OPfZY+vOf/5y1cgAQlJ1v3LiRbrzxRho7dix16tSJ2rZtSwMHDqSzzz6bFixYkNVyAGDH008/Teeddx4ddNBB1LdvX2Hn3bp1o0MPPZR+85vf0I4dO0zPnTdvHk2bNo169+5NHTp0oDFjxtDNN99seQ4AUbBzvlZ577336Je//CUdeeSR1KtXL3EO2/rUqVNFfHiDEuTTeK6Hr8f5/WH+zJgxI/B8AxA0sX7nnS/WeOJieCEzceJEsUD59NNP6eOPPxb7L7nkEvrLX/6SIRzASoC88OEFDCsCHn744WJRVF1dTStWrKARI0ZQaWlpTsoFgB92Xl5eTpMnTxYijnyx961vfYs6duxIn3zyCX322WcizL333ktXX311jkoGQDq8MOFFyr777is8h/Ts2ZPq6+tp0aJF9PXXX9PIkSPpnXfeoeLi4rTz7rvvPmHHbP+TJk2ioqIiWrhwIdXV1dE+++xD7777rljoABBFO//iiy9o1KhR4juHPfjgg6lHjx705Zdf0uLFi8X+k08+mV566SXxAy0AUR7P9bCNH3jggbRr1y7xA9XFF19Mf/vb37JaDgB8Jxlj5s+fnzzzzDOTCxYsyDj27LPPJlu1asU/bCSffPLJtGOJRCJ59NFHi2OXXnppcvv27WnHGxsbk4sXLw48/wAEaeennnqq2H/SSScld+zYkXbskUceEcdat26drKysDLwMAKjw/vvvJzdu3Jixf8OGDckjjzxS2Oz3vve9tGNLly5NFhQUiH7w+uuvp/bv3Lkzedxxx4lzuP8AEFU7/+KLL5LHHnts8o033kju3bs37Zy333472alTJ3HO7bffnpX8AxDUeK6nqakpOWnSpGTnzp2T559/vgh/8cUXB5xrAIIn1ot3O7iTc2fnCzg9jz32mNj/7W9/O2d5AyBoO+cJj/d/+OGH0vNGjRoljr/88stZyikA7uEfr9hee/bsmbb/7LPPFvtnzJiRcc5XX32VLCwsFMc/++yzLOYWAH/t3Io77rhDnDNixIhA8wZANu38D3/4gwjzpz/9KXnrrbdi8Q7yhli/827H+PHjxbaysjJt/wMPPCC2/A4xAPlq5+3bt1c6H48TgyjQunVrsWVtEo3du3enNB+mT5+ecc6QIUPoiCOOEN9feeWVrOUVAD/t3O0cAEBU7XzVqlVCs+Soo46iH//4x1nOHQDBgsW7BZ9//rnYsgidBr9v89FHH1GrVq3Ee+78Ps1vf/tbuuyyy+jaa6+lF154QVwQAhBlO2dOPPFEsb399tvF+2J6Hn30UXEeC9mVlJRkMbcAOGf79u102223ie+sVaKxevXqlG3ze8AytP1lZWVZySsAftu52zkAgCjaeVNTE51//vlCw+Sxxx7L0KwCIOo0/3QFMmChoieeeEJ8P/PMM1P7ly9fLrYs4MWiF9dcc41Q89YzfPhwcZeGRTIAiKKdM7///e+FqB3fmRw8eDAddthhKcG6lStX0kknnSQW8dov4ACEhTlz5tAzzzwjVLY1gSO+4DvhhBPo7rvvToVbs2aN2LLYaJcuXaRxsVCSPiwAUbNzK/jHK+1pQuMcAEAU7ZyvXT744AMhRMri0QDkG7jqlrB37176wQ9+IBTl+c7ipZdemuY6i9m0aRNdccUVdNZZZ9Gtt95KQ4cOFcrdV111lRg0eFBh1Xle5AMQNTtnWHH77bffFo+c/eMf/0hzKccLGnaJyC4SAQgb/KMTu/HUw4/F/+EPfxCuhjT4ApBh7wtmdO7cWWy3bdsWWH4BCNLOrbj88svFD1Os2H3TTTcFlFMAsmPnfB3O1+T8ZCxfowOQj+CxeQn8CDz7xeaF94svvpjmOkXzrMcLH35cmB+TP+CAA8QFHt+ZnDt3rlj01NbWwtc7iKydM3x3nd+FfO2114Qt8/uQvNDnBT3bOD91wn6x+RE1AMIE/4jKYzW/wsRustil4RtvvEH77befcO8JQD7g1c7vuOMOsShifZPnn38eNxtApO2cr8v5cfnCwkL6+9//LrYA5COwbANXXnmleEeGfaDyQnz06NFpx/WPVhrvVGrH+W6m5l8bgCjaOU+C/AglT5T8aDzffR84cCB17dpVCMDwY2zsM57Pfeqpp3JWDgCsaNOmjXhskn2488Xe5s2bxfjMPoL14/nOnTtN49ixY4fYsu0DEEU7l8F3LX/5y18KwS9+zU8TZgQgqnb+61//mpYuXSp0evbZZ59cZxeAwMDiXQffSeR3v/j9R16caAqsxvfZZd9lYfjuOwBRtHN+9YMfVeMLuzPOOCPjOC/6NUE7/EgFosC3vvUtcaeGnyApLS0V+/h1J2bLli2pR+iNaArcWlgAombnRh588EExD/DTVi+99JJ4zQ+AqNu55hGEnxY8+uij0z6atg+//qftAyCq4J33b7j++utT78/wgsZMeZjvUPLdGr7Q27BhgzSMtl97VxKAqNl5RUWF2LJAHXtWkKG9a8b6DwBEAe3d9nXr1okt351hG2fRLr4APOaYYzLO0S4MJ0yYkOXcAuCPnev505/+JN4F1hbuLDwKQD7Z+bvvvmsp0ssfAKIM7rwT0Q033CDUKXkxwo8BH3LIIaZhWVn7tNNOs7zjyHEwhx56aEA5BiBYOx8wYIDY8mNpmhsh2d15ZtiwYQHlGAD/4B9V2c0no70mwgsYbfHCasZG1q5dS++99574fvrpp2c1vwD4Zecaf/nLX+inP/1pauF+8skn5yiXAPhv58uWLRPvxss+LGLHXHzxxal9AESV2C/eb7nlFuFqgh8htlvQaLAiK797w+8C/+c//0k7xosj/tWP71b+5Cc/CTDnAARn5yzGqC3gZ8yYQevXr08dY3ctv/3tb4W7Fubcc88NOPcA2MOveTz99NPU0NCQcYz9uZ999tnU2NgohEXZu4L+Ry32A/z444/T7NmzU/v5bjxf6LEgI+s/jBkzJmtlAcBvO+frFVaWx8Id5LOdAxAHCpIx/vnp1Vdfpe985zviOz8+vP/++0vD9e7dm+655560fazQetFFF4mFDJ+ruYpjhW5euD/88MP0ox/9KCvlACAIO3/zzTfplFNOEYsYFuvid8z4lRH+tbu8vDz1QxaLxACQa9gLAj/2zo9Sso4DCyyyOjG/AsIiRjxW77vvvmKBPnjw4LRz2R8wiyDxIp4FGfv27UsLFy4UuiX8aD3/IMv9A4Ao2jnfkeTXPvhyj3+E4rHcDO3dYACiOp7LuO2224SQHf8g+7e//S0rZQAgKGK9eOdJ6sILL7QNN2TIEPrqq68y9i9evFjczeSLPH68mN2sTJo0ia699lo8Mg/yws6//PJL8Y48u5TjR4hZhZ59u/PFHyvQT506NcCcA6AOPx3Cdxd5POYfUfn/PXv2UM+ePcWdGRZe5H7AIowy+DUodkH04YcfCvV5viA866yz6MYbb0zzMgJA1OxcWwipEONLQpBH47kRLN5BPhHrxTsAAAAAAAAAABAFYv/OOwAAAAAAAAAAEHaweAcAAAAAAAAAAEIOFu8AAAAAAAAAAEDIweIdAAAAAAAAAAAIOVi8AwAAAAAAAAAAIQeLdwAAAAAAAAAAIORg8Q4AAAAAAAAAAIQcLN4BAAAAAAAAAICQg8U7AAAAAAAAAAAQcrB4BwAAAPKYo48+mgoKCigqJJNJmjhxIh1//PGuzr/llluoS5cuVF9f73veAAAAgFyCxTsAAAAQEXgR7uQTRZ566ilaunQp/epXv3J1/jXXXEOFhYV06623+p43AAAAIJcUJPknbgAAAACEnttuuy1j3/33309bt26VLlY5fEVFBe3atYvGjBlDYSeRSNCIESNo0KBBtGDBAtfx8AL+j3/8I5WXl9OQIUN8zSMAAACQK7B4BwAAACLM0KFDae3ateJx86gza9YsOvnkk+nRRx+lGTNmuI6nrKyMJkyYIB6hv+OOO3zNIwAAAJAr8Ng8AAAAELN33p944gmxj7evvfYafetb36KOHTvSgAED6Be/+IW4A848+eSTdNBBB1GHDh1o8ODB9Pvf/16aBv9w8Pe//52OOOII6tq1q4jr4IMPFvuc8Pjjj4t8nXnmmRnHamtr6corr6RRo0aJ/HTv3p323Xdfuuyyy8STB3rGjx9PI0eOFOUDAAAA8oXWuc4AAAAAAHLDK6+8QnPmzKHTTjtNLLz5zvedd94pFuPdunUT37/zne+IHwBeeukluv7666moqIjOO++8VBwc9vvf/z7985//FAvr6dOnU9u2bWnu3Ll08cUX06effkr33HOPbV44nrfeeov22Wcf6tGjR9oxfuyf8/fVV18JIbvTTz+ddu/eTWvWrKGZM2fStddeK/Krp6SkRBxbvXo1jR492sdaAwAAAHIDFu8AAABATHnjjTfof//7Hx1yyCHi/9tvv13csb7vvvvEHXR+/Hz48OHiGC+Q+RgvxPWL97/97W9i4X7hhRfSI488Qm3atBH7eXF91lln0b333kvnnnuuUJC34rPPPqNNmzbRiSeemHFs/vz5YqF+1VVXibzp2bFjRypNPXznnxfvXD4s3gEAAOQDeGweAAAAiCk/+MEPUgt3hl2s8TvnfKf7xz/+cWrhzrCI3JFHHinupO/duze1/6GHHqJOnTrRn/70p7RFNN99//Wvfy2+8+LejqqqKrHlO/tm8OPyRjp37kzt2rXL2K/Fo8ULAAAARB3ceQcAAABiyrhx4zL29e/f3/JYU1OT8KHO78fzIn/FihVUXFxMd999d0b4PXv2iO3KlStt87Jx40ax5XfZjUyePFmk/dvf/pY++ugj8QPDUUcdJd55N3OJ17NnT7HdsGGDbdoAAABAFMDiHQAAAIgp/Gi8kdatW9se0xblmzdvFu+qV1dXi0fuzdi5c6dtXrS76g0NDRnH+H32999/n375y18Kgb3XX3899TTADTfcQJdffnnGOV9//bXYsngeAAAAkA/gsXkAAAAAuEJb4PP77LyIN/uwEJ0dffr0EVt+710Gq92zevz69evFu/h8p59V8X/yk59IH8vX4tHiBQAAAKIOFu8AAAAAcAW/I8+PrrPY3JYtWzzFtf/++1NhYSGtWrXKMhyH4Uf6WfleW7S/+uqrGeG0eMaOHespXwAAAEBYwOIdAAAAAK654oorxLvvP/rRj6SPx7NKPLt4s4PfdT/wwAOptLQ05Wde45NPPhHv2RvR9rVv3z7j2AcffCAe8z/88MMdlggAAAAIJ3jnHQAAAACuufTSS8X76E8++aRwyzZlyhQhYMcLaxaq40X0M888Q0OHDrWNi/2333rrrSI+/aKbfcZfd911wtc7u33r1asXffnll+KOOy/c+dF5o/s4jmPq1KlCCR8AAADIB3DnHQAAAACuYbV3fhf9ueeeE4++/+c//6E//OEPYsHNC2v2C88LehVmzJgh7pb/4x//SNv/7W9/WyzQt23bRi+//LLw9c536L/73e/SkiVLhE93PS+99JIQrOMfFgAAAIB8oSDJSjIAAAAAACHghz/8Ic2aNYvWrl0r3ql3w6RJk8Sdf34Xv1WrVr7nEQAAAMgFuPMOAAAAgNBw5513irvmDz74oKvz58+fT++++65Qo8fCHQAAQD6BxTsAAAAAQsOQIUPE+/Nu77pv3bpVPKrP788DAAAA+QQemwcAAAAAAAAAAEIO7rwDAAAAAAAAAAAhB4t3AAAAAAAAAAAg5GDxDgAAAAAAAAAAhBws3gEAAAAAAAAAgJCDxTsAAAAAAAAAABBysHgHAAAAAAAAAABCDhbvAAAAAAAAAABAyMHiHQAAAAAAAAAACDlYvAMAAAAAAAAAABRu/h9TTN4KZzXGiQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for session_data in all_session_data:\n", + " session = session_data['session']\n", + " trial_start_time = session_data['trial_start_time']\n", + " trial_end_time = session_data['trial_end_time']\n", + " spike_times = session_data['spike_times']\n", + " spike_ids = session_data['spike_ids']\n", + " spike_counts = session_data['spike_counts']\n", + " z_labels = session_data['z_labels']\n", + " tg_times_sortind = np.argsort(tg_times)\n", + " tg_pos = tg_pos[tg_times_sortind, :]\n", + " tg_times = tg_times[tg_times_sortind]\n", + " y = session_data['y']\n", + " z = session_data['z']\n", + " t = session_data['t']\n", + " title_head = f'Sesssion {session} - '\n", + " zoom_period = np.array([trial_start_time[2], trial_start_time[2]+10])\n", + " plotSpikeRaster(spike_times, spike_ids, title_head=title_head, zoom_period=zoom_period, trial_start_time=trial_start_time, trial_end_time=trial_end_time)\n", + " plotSpikeCounts(t, spike_counts, y, title_head=title_head, zoom_period=zoom_period, trial_start_time=trial_start_time, trial_end_time=trial_end_time)\n", + " plotBehavior(t, z, labels=z_labels, title_head=title_head, trial_start_time=trial_start_time, zoom_period=zoom_period, trial_end_time=trial_end_time)\n", + " plotCursorPosition(z, tg_times, tg_pos, labels=z_labels, title_head=title_head, t=t, zoom_period=zoom_period, trial_start_time=trial_start_time, trial_end_time=trial_end_time)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### **Notes about the following analyses**:\n", + "1) The following procedures needs to be repeated for each fold within each analyzed dataset/session. Here we only model data from fold one of one of the sessions for simplicity. Please refer to FAQ #2 for more on this.\n", + "2) Here as an example we set nx=n1=16 for simplicity. Note that in practice, one needs to explore various dimensions and select the number of behaviorally relevant states (n1) and the total number of states (nx) accordingly. Please refer to FAQ #1 for more details on how to select the state dimensions.\n", + "\n", + " So for example for modeling a dataset including 3 sessions, with 5 cross-validated folds, and exploring 6 different state dimensions (6 different (nx,n1) pairs), one needs to run flexible DPAD/DPAD with user-defined nonlinearity $3*5*6=90$ times. These 90 runs can be done in parallel for efficiency. We suggest sending these parallel runs as separate jobs to a high performance computing cluster. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Modeling of neural-behavioral data: Flexible DPAD\n", + "\n", + "### We use flexible DPAD to model the data. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "## Preparing data for session 2 and fold 1/5 for this example. In this example we use 16 dimensional states (all behaviorally relevant).\n", + "session_data = all_session_data[1] # Session 2 as an example\n", + "allYData = session_data['y'] # Preprocessed neural data\n", + "allZData = session_data['z'] # Behavior data\n", + "N = allYData.shape[0] # Total number of samples in session 1\n", + "\n", + "# Separate data into training and test data (first fold from a 5-fold cross-validation):\n", + "testInds = np.arange(np.round(0.2 * N), dtype=int)\n", + "trainInds = np.arange(1 + testInds[-1], N)\n", + "yTrain = allYData[trainInds, :]\n", + "yTest = allYData[testInds, :]\n", + "zTrain = allZData[trainInds, :]\n", + "zTest = allZData[testInds, :]\n", + "\n", + "nx = n1 = 16 # In this example we use 16 dimensional states (all behaviorally relevant)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We first run flexible DPAD (step 1.1) to select the nonlionearity resulting in **best behavior decoding** in this dataset. This is the primary use-case of DPAD. If interested in the configuration with best neural serlf-prediction instead, please follow the next example where we show how to use flexible DPAD and select the nonlinearity resulting in the best neural self-prediction instead of behavior decoding." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:24:26\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 249] \u001b[1;30mINFO\u001b[0m Running innerCV to choose among the following 16 variants:\n", + "(1) DPAD_RTR2_ErSV16\n", + "(2) DPAD_RTR2_A1HL64U_ErSV16\n", + "(3) DPAD_RTR2_K1HL64U_ErSV16\n", + "(4) DPAD_RTR2_Cz1HL64U_ErSV16\n", + "(5) DPAD_RTR2_Cy1HL64U_ErSV16\n", + "(6) DPAD_RTR2_uAK1HL64U_ErSV16\n", + "(7) DPAD_RTR2_ACz1HL64U_ErSV16\n", + "(8) DPAD_RTR2_ACy1HL64U_ErSV16\n", + "(9) DPAD_RTR2_KCz1HL64U_ErSV16\n", + "(10) DPAD_RTR2_KCy1HL64U_ErSV16\n", + "(11) DPAD_RTR2_CzCy1HL64U_ErSV16\n", + "(12) DPAD_RTR2_uAKCz1HL64U_ErSV16\n", + "(13) DPAD_RTR2_uAKCy1HL64U_ErSV16\n", + "(14) DPAD_RTR2_ACzCy1HL64U_ErSV16\n", + "(15) DPAD_RTR2_KCzCy1HL64U_ErSV16\n", + "(16) DPAD_RTR2_uAKCzCy1HL64U_ErSV16\n", + "\u001b[32m2025-05-30 10:24:26\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 637] \u001b[1;30mINFO\u001b[0m Assuming new run because no result file was found in ..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p\n", + "\u001b[32m2025-05-30 10:24:26\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1381] \u001b[1;30mINFO\u001b[0m Fold 1/4: training samples: 8014, test samples=2672\n", + "\u001b[32m2025-05-30 10:24:26\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1754] \u001b[1;30mINFO\u001b[0m Running fold 1 (NTrain=8014, NTest=2672)\n", + "\u001b[32m2025-05-30 10:24:26\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1849] \u001b[1;30mINFO\u001b[0m Signal dimensions: y => (10686, 46), z => (10686, 4), u => None\n", + "\u001b[32m2025-05-30 10:24:26\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1856] \u001b[1;30mINFO\u001b[0m Method codes to fit: ['DPAD_RTR2_ErSV16', 'DPAD_RTR2_A1HL64U_ErSV16', 'DPAD_RTR2_K1HL64U_ErSV16', 'DPAD_RTR2_Cz1HL64U_ErSV16', 'DPAD_RTR2_Cy1HL64U_ErSV16', 'DPAD_RTR2_uAK1HL64U_ErSV16', 'DPAD_RTR2_ACz1HL64U_ErSV16', 'DPAD_RTR2_ACy1HL64U_ErSV16', 'DPAD_RTR2_KCz1HL64U_ErSV16', 'DPAD_RTR2_KCy1HL64U_ErSV16', 'DPAD_RTR2_CzCy1HL64U_ErSV16', 'DPAD_RTR2_uAKCz1HL64U_ErSV16', 'DPAD_RTR2_uAKCy1HL64U_ErSV16', 'DPAD_RTR2_ACzCy1HL64U_ErSV16', 'DPAD_RTR2_KCzCy1HL64U_ErSV16', 'DPAD_RTR2_uAKCzCy1HL64U_ErSV16']\n", + "\u001b[32m2025-05-30 10:24:26\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1857] \u001b[1;30mINFO\u001b[0m Nx values to fit: [16]\n", + "\u001b[32m2025-05-30 10:24:26\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_ErSV16\" (1/16)\n", + "\u001b[32m2025-05-30 10:24:26\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 10:24:26\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 10:24:26\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Considering 16 possible combinations of location/type for nonlinearities (this might take a while)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:24:26\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 10:24:26\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 10:24:26\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 10:24:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:28:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/2500 - loss=rnn_1step_loss=1.000152, rnn_1step_R2_maskV_-1.0=-0.023116767, rnn_1step_CC_maskV_-1.0=-0.0070318393, rnn_1step_MSE_maskV_-1.0=1.0001521, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96705598, val_rnn_1step_R2_maskV_-1.0=-0.090282321, val_rnn_1step_CC_maskV_-1.0=0.010060819, learning_rate=0.001\n", + "Epoch 251/2500 - loss=rnn_1step_loss=0.42187414, rnn_1step_R2_maskV_-1.0=0.56494141, rnn_1step_CC_maskV_-1.0=0.75854319, rnn_1step_MSE_maskV_-1.0=0.42187411, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53996873, val_rnn_1step_R2_maskV_-1.0=0.38084728, val_rnn_1step_CC_maskV_-1.0=0.68125951, learning_rate=0.001\n", + "Epoch 501/2500 - loss=rnn_1step_loss=0.41296127, rnn_1step_R2_maskV_-1.0=0.57343477, rnn_1step_CC_maskV_-1.0=0.76448393, rnn_1step_MSE_maskV_-1.0=0.4129613, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5336473, val_rnn_1step_R2_maskV_-1.0=0.38843697, val_rnn_1step_CC_maskV_-1.0=0.68607801, learning_rate=0.001\n", + "Epoch 751/2500 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40924779, rnn_1step_R2_maskV_-1.0=0.57717049, rnn_1step_CC_maskV_-1.0=0.7669934, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52817184, val_rnn_1step_R2_maskV_-1.0=0.3949005, val_rnn_1step_CC_maskV_-1.0=0.68923628, learning_rate=0.001\n", + "Epoch 1001/2500 - loss=rnn_1step_loss=0.4084104, rnn_1step_R2_maskV_-1.0=0.57808304, rnn_1step_CC_maskV_-1.0=0.76756448, rnn_1step_MSE_maskV_-1.0=0.40841037, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52540326, val_rnn_1step_R2_maskV_-1.0=0.39816135, val_rnn_1step_CC_maskV_-1.0=0.69101542, learning_rate=0.001\n", + "Epoch 1251/2500 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40793157, rnn_1step_R2_maskV_-1.0=0.57862139, rnn_1step_CC_maskV_-1.0=0.76790547, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52253747, val_rnn_1step_R2_maskV_-1.0=0.40150458, val_rnn_1step_CC_maskV_-1.0=0.69285113, learning_rate=0.001\n", + "Epoch 1501/2500 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40758851, rnn_1step_R2_maskV_-1.0=0.57903111, rnn_1step_CC_maskV_-1.0=0.76815575, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52014619, val_rnn_1step_R2_maskV_-1.0=0.40425533, val_rnn_1step_CC_maskV_-1.0=0.6944418, learning_rate=0.001\n", + "Epoch 1751/2500 - loss=rnn_1step_loss=0.40760222, rnn_1step_R2_maskV_-1.0=0.57908863, rnn_1step_CC_maskV_-1.0=0.76818484, rnn_1step_MSE_maskV_-1.0=0.40760225, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51878947, val_rnn_1step_R2_maskV_-1.0=0.40579981, val_rnn_1step_CC_maskV_-1.0=0.69547981, learning_rate=0.001\n", + "Epoch 2001/2500 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40802217, rnn_1step_R2_maskV_-1.0=0.57871473, rnn_1step_CC_maskV_-1.0=0.76794875, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51818287, val_rnn_1step_R2_maskV_-1.0=0.40647417, val_rnn_1step_CC_maskV_-1.0=0.69599032, learning_rate=0.001\n", + "Epoch 2251/2500 - loss=rnn_1step_loss=0.40829143, rnn_1step_R2_maskV_-1.0=0.57849205, rnn_1step_CC_maskV_-1.0=0.76781821, rnn_1step_MSE_maskV_-1.0=0.4082914, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51723635, val_rnn_1step_R2_maskV_-1.0=0.40756044, val_rnn_1step_CC_maskV_-1.0=0.69645226, learning_rate=0.001\n", + "Epoch 2500/2500 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4091076, rnn_1step_R2_maskV_-1.0=0.57780808, rnn_1step_CC_maskV_-1.0=0.76750487, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51829535, val_rnn_1step_R2_maskV_-1.0=0.40634704, val_rnn_1step_CC_maskV_-1.0=0.69582814, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:28:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 245.11s\n", + "\u001b[32m2025-05-30 10:28:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:32:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 2352 (stopped at 2367 epochs).\n", + "\u001b[32m2025-05-30 10:32:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/2368 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.99723619, rnn_1_1step_R2_maskV_-1.0=-0.019976992, rnn_1_1step_CC_maskV_-1.0=0.055725537, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.95955306, val_rnn_1_1step_R2_maskV_-1.0=-0.081557289, val_rnn_1_1step_CC_maskV_-1.0=0.16301411, learning_rate=0.001\n", + "Epoch 238/2368 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41707551, rnn_1_1step_R2_maskV_-1.0=0.56973916, rnn_1_1step_CC_maskV_-1.0=0.76174164, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53800672, val_rnn_1_1step_R2_maskV_-1.0=0.38303506, val_rnn_1_1step_CC_maskV_-1.0=0.68275231, learning_rate=0.001\n", + "Epoch 475/2368 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40775141, rnn_1_1step_R2_maskV_-1.0=0.5786978, rnn_1_1step_CC_maskV_-1.0=0.76797605, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53114974, val_rnn_1_1step_R2_maskV_-1.0=0.39144123, val_rnn_1_1step_CC_maskV_-1.0=0.6876151, learning_rate=0.001\n", + "Epoch 712/2368 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40774456, rnn_1_1step_R2_maskV_-1.0=0.57871449, rnn_1_1step_CC_maskV_-1.0=0.76799047, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52847344, val_rnn_1_1step_R2_maskV_-1.0=0.39461616, val_rnn_1_1step_CC_maskV_-1.0=0.68963987, learning_rate=0.001\n", + "Epoch 949/2368 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40810657, rnn_1_1step_R2_maskV_-1.0=0.57840925, rnn_1_1step_CC_maskV_-1.0=0.76774347, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52680176, val_rnn_1_1step_R2_maskV_-1.0=0.39651585, val_rnn_1_1step_CC_maskV_-1.0=0.69081998, learning_rate=0.001\n", + "Epoch 1186/2368 - loss=rnn_1_1step_loss=0.40847382, rnn_1_1step_R2_maskV_-1.0=0.57806849, rnn_1_1step_CC_maskV_-1.0=0.76747006, rnn_1_1step_MSE_maskV_-1.0=0.40847379, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52552164, val_rnn_1_1step_R2_maskV_-1.0=0.39795235, val_rnn_1_1step_CC_maskV_-1.0=0.69156599, learning_rate=0.001\n", + "Epoch 1423/2368 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40878329, rnn_1_1step_R2_maskV_-1.0=0.57780045, rnn_1_1step_CC_maskV_-1.0=0.76724374, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52403611, val_rnn_1_1step_R2_maskV_-1.0=0.39964592, val_rnn_1_1step_CC_maskV_-1.0=0.69237345, learning_rate=0.001\n", + "Epoch 1660/2368 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40895876, rnn_1_1step_R2_maskV_-1.0=0.5777064, rnn_1_1step_CC_maskV_-1.0=0.7671414, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52249902, val_rnn_1_1step_R2_maskV_-1.0=0.40143198, val_rnn_1_1step_CC_maskV_-1.0=0.69318885, learning_rate=0.001\n", + "Epoch 1897/2368 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40933767, rnn_1_1step_R2_maskV_-1.0=0.57741427, rnn_1_1step_CC_maskV_-1.0=0.76693356, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52143598, val_rnn_1_1step_R2_maskV_-1.0=0.40265805, val_rnn_1_1step_CC_maskV_-1.0=0.6937151, learning_rate=0.001\n", + "Epoch 2134/2368 - loss=rnn_1_1step_loss=0.4092519, rnn_1_1step_R2_maskV_-1.0=0.57753009, rnn_1_1step_CC_maskV_-1.0=0.76704293, rnn_1_1step_MSE_maskV_-1.0=0.40925187, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5206598, val_rnn_1_1step_R2_maskV_-1.0=0.40353876, val_rnn_1_1step_CC_maskV_-1.0=0.69413966, learning_rate=0.001\n", + "Epoch 2368/2368 - loss=rnn_1_1step_loss=0.40878153, rnn_1_1step_R2_maskV_-1.0=0.57797635, rnn_1_1step_CC_maskV_-1.0=0.76740968, rnn_1_1step_MSE_maskV_-1.0=0.4087815, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52027386, val_rnn_1_1step_R2_maskV_-1.0=0.40393272, val_rnn_1_1step_CC_maskV_-1.0=0.69426996, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:32:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 230.42s\n", + "\u001b[32m2025-05-30 10:32:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.51513165)\n", + "\u001b[32m2025-05-30 10:32:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.367, R2_maskV_-1.0=0.632, CC_maskV_-1.0=0.796\n", + "\u001b[32m2025-05-30 10:32:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.5, R2_maskV_-1.0=0.44, CC_maskV_-1.0=0.714\n", + "\u001b[32m2025-05-30 10:32:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 10:32:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:32:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 114 (stopped at 129 epochs).\n", + "\u001b[32m2025-05-30 10:32:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/130 - loss=368.42407, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=-0.011057582, MSE_maskV_-1.0=367.36465, val_loss=36.590637, val_CC_maskV_-1.0=-0.01890341, val_MSE_maskV_-1.0=36.249817, learning_rate=0.001\n", + "Epoch 14/130 - loss=1.8939855, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.096346781, MSE_maskV_-1.0=1.8981507, val_loss=1.79766, val_CC_maskV_-1.0=0.11056576, val_MSE_maskV_-1.0=1.8017246, learning_rate=0.001\n", + "Epoch 27/130 - loss=1.1939547, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.18735114, MSE_maskV_-1.0=1.194272, val_loss=1.1884521, val_CC_maskV_-1.0=0.19332498, val_MSE_maskV_-1.0=1.1855491, learning_rate=0.001\n", + "Epoch 40/130 - loss=1.0385486, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.24947628, MSE_maskV_-1.0=1.0381759, val_loss=1.0460365, val_CC_maskV_-1.0=0.24212174, val_MSE_maskV_-1.0=1.0428309, learning_rate=0.001\n", + "Epoch 53/130 - loss=0.97482461, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.29298741, MSE_maskV_-1.0=0.97409463, val_loss=0.9829942, val_CC_maskV_-1.0=0.28979322, val_MSE_maskV_-1.0=0.97869766, learning_rate=0.001\n", + "Epoch 66/130 - loss=0.93089539, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.32607412, MSE_maskV_-1.0=0.93065238, val_loss=0.93559796, val_CC_maskV_-1.0=0.32576081, val_MSE_maskV_-1.0=0.93278205, learning_rate=0.001\n", + "Epoch 79/130 - loss=0.90526706, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34837836, MSE_maskV_-1.0=0.90567857, val_loss=0.89707834, val_CC_maskV_-1.0=0.357876, val_MSE_maskV_-1.0=0.89401793, learning_rate=0.001\n", + "Epoch 92/130 - loss=0.88678628, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36532605, MSE_maskV_-1.0=0.88565779, val_loss=0.90537792, val_CC_maskV_-1.0=0.36547974, val_MSE_maskV_-1.0=0.90258819, learning_rate=0.001\n", + "Epoch 105/130 - loss=0.87574875, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37648949, MSE_maskV_-1.0=0.8752864, val_loss=0.88736564, val_CC_maskV_-1.0=0.37955254, val_MSE_maskV_-1.0=0.88346857, learning_rate=0.001\n", + "Epoch 118/130 - loss=0.86355633, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38909063, MSE_maskV_-1.0=0.86352211, val_loss=0.87606907, val_CC_maskV_-1.0=0.38617542, val_MSE_maskV_-1.0=0.87401223, learning_rate=0.001\n", + "Epoch 130/130 - loss=0.85928237, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39398223, MSE_maskV_-1.0=0.8615604, val_loss=0.87625968, val_CC_maskV_-1.0=0.38804141, val_MSE_maskV_-1.0=0.87418795, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:32:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 32.30s\n", + "\u001b[32m2025-05-30 10:32:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:33:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 77 (stopped at 92 epochs).\n", + "\u001b[32m2025-05-30 10:33:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/93 - loss=567.34271, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0032488594, MSE_maskV_-1.0=565.76031, val_loss=59.390121, val_CC_maskV_-1.0=0.026797362, val_MSE_maskV_-1.0=58.973129, learning_rate=0.001\n", + "Epoch 11/93 - loss=2.3219304, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.10080051, MSE_maskV_-1.0=2.3238237, val_loss=2.2769544, val_CC_maskV_-1.0=0.088058986, val_MSE_maskV_-1.0=2.272634, learning_rate=0.001\n", + "Epoch 21/93 - loss=1.3974841, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.15231232, MSE_maskV_-1.0=1.3972917, val_loss=1.4033611, val_CC_maskV_-1.0=0.13716191, val_MSE_maskV_-1.0=1.4003028, learning_rate=0.001\n", + "Epoch 31/93 - loss=1.1331341, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.20936994, MSE_maskV_-1.0=1.1331173, val_loss=1.1390109, val_CC_maskV_-1.0=0.2060419, val_MSE_maskV_-1.0=1.1371473, learning_rate=0.001\n", + "Epoch 41/93 - loss=1.024242, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.25991896, MSE_maskV_-1.0=1.0246464, val_loss=1.0498605, val_CC_maskV_-1.0=0.24329671, val_MSE_maskV_-1.0=1.0500109, learning_rate=0.001\n", + "Epoch 51/93 - loss=0.96539205, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.29690257, MSE_maskV_-1.0=0.96451241, val_loss=0.99368721, val_CC_maskV_-1.0=0.28066456, val_MSE_maskV_-1.0=0.99209005, learning_rate=0.001\n", + "Epoch 61/93 - loss=0.93782824, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.32040545, MSE_maskV_-1.0=0.93698871, val_loss=0.91944486, val_CC_maskV_-1.0=0.33536226, val_MSE_maskV_-1.0=0.91814429, learning_rate=0.001\n", + "Epoch 71/93 - loss=0.91502047, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.33940387, MSE_maskV_-1.0=0.91588354, val_loss=0.97683591, val_CC_maskV_-1.0=0.3150045, val_MSE_maskV_-1.0=0.97342771, learning_rate=0.001\n", + "Epoch 81/93 - loss=0.89839071, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35394439, MSE_maskV_-1.0=0.89819103, val_loss=0.90453339, val_CC_maskV_-1.0=0.35369736, val_MSE_maskV_-1.0=0.90250486, learning_rate=0.001\n", + "Epoch 91/93 - loss=0.88784945, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3645891, MSE_maskV_-1.0=0.88835138, val_loss=0.8896094, val_CC_maskV_-1.0=0.37061703, val_MSE_maskV_-1.0=0.88745087, learning_rate=0.001\n", + "Epoch 93/93 - loss=0.87807941, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37270311, MSE_maskV_-1.0=0.87713987, val_loss=0.88947874, val_CC_maskV_-1.0=0.37178588, val_MSE_maskV_-1.0=0.88763279, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:33:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 23.36s\n", + "\u001b[32m2025-05-30 10:33:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.85752451)\n", + "\u001b[32m2025-05-30 10:33:19\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 721us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:33:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.852, R2_maskV_-1.0=0.147, CC_maskV_-1.0=0.397\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 738us/step\n", + "51/51 [==============================] - 0s 771us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:33:20\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_ErSV16\" (1/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 10:33:20\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_A1HL64U_ErSV16\" (2/16)\n", + "\u001b[32m2025-05-30 10:33:20\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_A1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 10:33:20\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 10:33:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 10:33:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 10:33:20\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 10:33:20\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 10:33:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:33:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 133 (stopped at 148 epochs).\n", + "\u001b[32m2025-05-30 10:33:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/149 - loss=rnn_1step_loss=0.99952477, rnn_1step_R2_maskV_-1.0=-0.022544902, rnn_1step_CC_maskV_-1.0=0.01364237, rnn_1step_MSE_maskV_-1.0=0.99952471, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96190643, val_rnn_1step_R2_maskV_-1.0=-0.084765211, val_rnn_1step_CC_maskV_-1.0=0.1055524, learning_rate=0.001\n", + "Epoch 16/149 - loss=rnn_1step_loss=0.74744326, rnn_1step_R2_maskV_-1.0=0.22800767, rnn_1step_CC_maskV_-1.0=0.50354803, rnn_1step_MSE_maskV_-1.0=0.74744332, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.76019698, val_rnn_1step_R2_maskV_-1.0=0.13066673, val_rnn_1step_CC_maskV_-1.0=0.46180978, learning_rate=0.001\n", + "Epoch 31/149 - loss=rnn_1step_loss=0.61163449, rnn_1step_R2_maskV_-1.0=0.36761379, rnn_1step_CC_maskV_-1.0=0.62150228, rnn_1step_MSE_maskV_-1.0=0.61163455, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.68376875, val_rnn_1step_R2_maskV_-1.0=0.21808319, val_rnn_1step_CC_maskV_-1.0=0.5479759, learning_rate=0.001\n", + "Epoch 46/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.54631621, rnn_1step_R2_maskV_-1.0=0.43410087, rnn_1step_CC_maskV_-1.0=0.67206752, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.65126163, val_rnn_1step_R2_maskV_-1.0=0.25809649, val_rnn_1step_CC_maskV_-1.0=0.58069366, learning_rate=0.001\n", + "Epoch 61/149 - loss=rnn_1step_loss=0.50715178, rnn_1step_R2_maskV_-1.0=0.47473571, rnn_1step_CC_maskV_-1.0=0.70096701, rnn_1step_MSE_maskV_-1.0=0.50715184, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63362813, val_rnn_1step_R2_maskV_-1.0=0.27801269, val_rnn_1step_CC_maskV_-1.0=0.59930915, learning_rate=0.001\n", + "Epoch 76/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.46576366, rnn_1step_R2_maskV_-1.0=0.51716387, rnn_1step_CC_maskV_-1.0=0.73019975, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60860628, val_rnn_1step_R2_maskV_-1.0=0.30648929, val_rnn_1step_CC_maskV_-1.0=0.62173325, learning_rate=0.001\n", + "Epoch 91/149 - loss=rnn_1step_loss=0.4262917, rnn_1step_R2_maskV_-1.0=0.55739582, rnn_1step_CC_maskV_-1.0=0.75728083, rnn_1step_MSE_maskV_-1.0=0.42629173, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59099293, val_rnn_1step_R2_maskV_-1.0=0.32587123, val_rnn_1step_CC_maskV_-1.0=0.634579, learning_rate=0.001\n", + "Epoch 106/149 - loss=rnn_1step_loss=0.39190912, rnn_1step_R2_maskV_-1.0=0.59363306, rnn_1step_CC_maskV_-1.0=0.77874571, rnn_1step_MSE_maskV_-1.0=0.39190909, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57101506, val_rnn_1step_R2_maskV_-1.0=0.34854773, val_rnn_1step_CC_maskV_-1.0=0.65200096, learning_rate=0.001\n", + "Epoch 121/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37469855, rnn_1step_R2_maskV_-1.0=0.61248362, rnn_1step_CC_maskV_-1.0=0.78960049, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57219511, val_rnn_1step_R2_maskV_-1.0=0.34623897, val_rnn_1step_CC_maskV_-1.0=0.65266931, learning_rate=0.001\n", + "Epoch 136/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37041363, rnn_1step_R2_maskV_-1.0=0.61661345, rnn_1step_CC_maskV_-1.0=0.79227602, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56194729, val_rnn_1step_R2_maskV_-1.0=0.35901541, val_rnn_1step_CC_maskV_-1.0=0.66123003, learning_rate=0.001\n", + "Epoch 149/149 - loss=rnn_1step_loss=0.36374906, rnn_1step_R2_maskV_-1.0=0.62355137, rnn_1step_CC_maskV_-1.0=0.79654306, rnn_1step_MSE_maskV_-1.0=0.36374903, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57550842, val_rnn_1step_R2_maskV_-1.0=0.34120774, val_rnn_1step_CC_maskV_-1.0=0.65372431, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:33:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 20.15s\n", + "\u001b[32m2025-05-30 10:33:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:33:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 60 (stopped at 75 epochs).\n", + "\u001b[32m2025-05-30 10:33:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/76 - loss=rnn_1_1step_loss=0.99640876, rnn_1_1step_R2_maskV_-1.0=-0.019305214, rnn_1_1step_CC_maskV_-1.0=0.086735472, rnn_1_1step_MSE_maskV_-1.0=0.99640882, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.95804375, val_rnn_1_1step_R2_maskV_-1.0=-0.080011919, val_rnn_1_1step_CC_maskV_-1.0=0.23131512, learning_rate=0.001\n", + "Epoch 9/76 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.90997523, rnn_1_1step_R2_maskV_-1.0=0.069539472, rnn_1_1step_CC_maskV_-1.0=0.41114259, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.8695305, val_rnn_1_1step_R2_maskV_-1.0=0.017084867, val_rnn_1_1step_CC_maskV_-1.0=0.39986801, learning_rate=0.001\n", + "Epoch 17/76 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.70680618, rnn_1_1step_R2_maskV_-1.0=0.27196354, rnn_1_1step_CC_maskV_-1.0=0.54404998, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.72280651, val_rnn_1_1step_R2_maskV_-1.0=0.17399953, val_rnn_1_1step_CC_maskV_-1.0=0.51623458, learning_rate=0.001\n", + "Epoch 25/76 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.59113741, rnn_1_1step_R2_maskV_-1.0=0.38754058, rnn_1_1step_CC_maskV_-1.0=0.63862193, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63919765, val_rnn_1_1step_R2_maskV_-1.0=0.27194813, val_rnn_1_1step_CC_maskV_-1.0=0.58833551, learning_rate=0.001\n", + "Epoch 33/76 - loss=rnn_1_1step_loss=0.54249221, rnn_1_1step_R2_maskV_-1.0=0.4383564, rnn_1_1step_CC_maskV_-1.0=0.67548835, rnn_1_1step_MSE_maskV_-1.0=0.54249215, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6216138, val_rnn_1_1step_R2_maskV_-1.0=0.29238734, val_rnn_1_1step_CC_maskV_-1.0=0.60223615, learning_rate=0.001\n", + "Epoch 41/76 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.50629133, rnn_1_1step_R2_maskV_-1.0=0.476053, rnn_1_1step_CC_maskV_-1.0=0.7018249, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61727512, val_rnn_1_1step_R2_maskV_-1.0=0.29710495, val_rnn_1_1step_CC_maskV_-1.0=0.61124265, learning_rate=0.001\n", + "Epoch 49/76 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.47654557, rnn_1_1step_R2_maskV_-1.0=0.50598156, rnn_1_1step_CC_maskV_-1.0=0.72243226, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61447716, val_rnn_1_1step_R2_maskV_-1.0=0.30002451, val_rnn_1_1step_CC_maskV_-1.0=0.61447144, learning_rate=0.001\n", + "Epoch 57/76 - loss=rnn_1_1step_loss=0.45800802, rnn_1_1step_R2_maskV_-1.0=0.52474397, rnn_1_1step_CC_maskV_-1.0=0.73486394, rnn_1_1step_MSE_maskV_-1.0=0.45800799, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60991836, val_rnn_1_1step_R2_maskV_-1.0=0.30458489, val_rnn_1_1step_CC_maskV_-1.0=0.61972916, learning_rate=0.001\n", + "Epoch 65/76 - loss=rnn_1_1step_loss=0.44383135, rnn_1_1step_R2_maskV_-1.0=0.53946817, rnn_1_1step_CC_maskV_-1.0=0.74551725, rnn_1_1step_MSE_maskV_-1.0=0.44383141, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58884126, val_rnn_1_1step_R2_maskV_-1.0=0.33006227, val_rnn_1_1step_CC_maskV_-1.0=0.63246387, learning_rate=0.001\n", + "Epoch 73/76 - loss=rnn_1_1step_loss=0.42688397, rnn_1_1step_R2_maskV_-1.0=0.55682117, rnn_1_1step_CC_maskV_-1.0=0.75598252, rnn_1_1step_MSE_maskV_-1.0=0.426884, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59517246, val_rnn_1_1step_R2_maskV_-1.0=0.32116807, val_rnn_1_1step_CC_maskV_-1.0=0.62994224, learning_rate=0.001\n", + "Epoch 76/76 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42240953, rnn_1_1step_R2_maskV_-1.0=0.56142545, rnn_1_1step_CC_maskV_-1.0=0.75815886, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59566146, val_rnn_1_1step_R2_maskV_-1.0=0.32006556, val_rnn_1_1step_CC_maskV_-1.0=0.6303435, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:33:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 11.37s\n", + "\u001b[32m2025-05-30 10:33:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.52835459)\n", + "\u001b[32m2025-05-30 10:33:53\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.335, R2_maskV_-1.0=0.665, CC_maskV_-1.0=0.817\n", + "\u001b[32m2025-05-30 10:33:53\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.494, R2_maskV_-1.0=0.453, CC_maskV_-1.0=0.706\n", + "\u001b[32m2025-05-30 10:33:53\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 10:33:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:34:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 125 (stopped at 140 epochs).\n", + "\u001b[32m2025-05-30 10:34:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/141 - loss=1.9422077, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.01479185, MSE_maskV_-1.0=1.9420738, val_loss=1.1838857, val_CC_maskV_-1.0=0.070407651, val_MSE_maskV_-1.0=1.1783774, learning_rate=0.001\n", + "Epoch 16/141 - loss=0.796534, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45168373, MSE_maskV_-1.0=0.79714864, val_loss=0.79943317, val_CC_maskV_-1.0=0.45406061, val_MSE_maskV_-1.0=0.7977007, learning_rate=0.001\n", + "Epoch 31/141 - loss=0.76317424, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48613223, MSE_maskV_-1.0=0.7635352, val_loss=0.7653293, val_CC_maskV_-1.0=0.48711377, val_MSE_maskV_-1.0=0.76384443, learning_rate=0.001\n", + "Epoch 46/141 - loss=0.7505123, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49919847, MSE_maskV_-1.0=0.7506364, val_loss=0.75479448, val_CC_maskV_-1.0=0.49675438, val_MSE_maskV_-1.0=0.75339866, learning_rate=0.001\n", + "Epoch 61/141 - loss=0.74489188, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50391734, MSE_maskV_-1.0=0.74440604, val_loss=0.74699873, val_CC_maskV_-1.0=0.50390846, val_MSE_maskV_-1.0=0.74550223, learning_rate=0.001\n", + "Epoch 76/141 - loss=0.74157393, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50658303, MSE_maskV_-1.0=0.74139076, val_loss=0.7457183, val_CC_maskV_-1.0=0.50495785, val_MSE_maskV_-1.0=0.74430561, learning_rate=0.001\n", + "Epoch 91/141 - loss=0.73957211, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50979435, MSE_maskV_-1.0=0.73973167, val_loss=0.74503845, val_CC_maskV_-1.0=0.50558025, val_MSE_maskV_-1.0=0.74361098, learning_rate=0.001\n", + "Epoch 106/141 - loss=0.73885524, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50935245, MSE_maskV_-1.0=0.73820519, val_loss=0.74393302, val_CC_maskV_-1.0=0.50651526, val_MSE_maskV_-1.0=0.74245828, learning_rate=0.001\n", + "Epoch 121/141 - loss=0.73804492, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51054317, MSE_maskV_-1.0=0.73808229, val_loss=0.74349594, val_CC_maskV_-1.0=0.5075376, val_MSE_maskV_-1.0=0.74183679, learning_rate=0.001\n", + "Epoch 136/141 - loss=0.73747706, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51130819, MSE_maskV_-1.0=0.73782909, val_loss=0.74313587, val_CC_maskV_-1.0=0.50727606, val_MSE_maskV_-1.0=0.74173331, learning_rate=0.001\n", + "Epoch 141/141 - loss=0.73731238, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51090181, MSE_maskV_-1.0=0.74126971, val_loss=0.74272323, val_CC_maskV_-1.0=0.5075804, val_MSE_maskV_-1.0=0.7413348, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:34:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 35.08s\n", + "\u001b[32m2025-05-30 10:34:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:34:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 90 (stopped at 105 epochs).\n", + "\u001b[32m2025-05-30 10:34:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/106 - loss=1.7167041, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.031928863, MSE_maskV_-1.0=1.7167093, val_loss=1.0990711, val_CC_maskV_-1.0=0.11200088, val_MSE_maskV_-1.0=1.0959427, learning_rate=0.001\n", + "Epoch 12/106 - loss=0.81060863, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43624461, MSE_maskV_-1.0=0.81014824, val_loss=0.8126877, val_CC_maskV_-1.0=0.44032156, val_MSE_maskV_-1.0=0.81066018, learning_rate=0.001\n", + "Epoch 23/106 - loss=0.77483398, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47543696, MSE_maskV_-1.0=0.77464443, val_loss=0.77931327, val_CC_maskV_-1.0=0.47530437, val_MSE_maskV_-1.0=0.7773096, learning_rate=0.001\n", + "Epoch 34/106 - loss=0.75882864, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49037603, MSE_maskV_-1.0=0.7605589, val_loss=0.761801, val_CC_maskV_-1.0=0.49156913, val_MSE_maskV_-1.0=0.75991648, learning_rate=0.001\n", + "Epoch 45/106 - loss=0.75060284, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49876404, MSE_maskV_-1.0=0.7501598, val_loss=0.7539351, val_CC_maskV_-1.0=0.49754661, val_MSE_maskV_-1.0=0.75236297, learning_rate=0.001\n", + "Epoch 56/106 - loss=0.74583817, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50336742, MSE_maskV_-1.0=0.74573624, val_loss=0.75113785, val_CC_maskV_-1.0=0.50008315, val_MSE_maskV_-1.0=0.74935967, learning_rate=0.001\n", + "Epoch 67/106 - loss=0.74273038, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50616693, MSE_maskV_-1.0=0.74214375, val_loss=0.74758899, val_CC_maskV_-1.0=0.50291353, val_MSE_maskV_-1.0=0.74631852, learning_rate=0.001\n", + "Epoch 78/106 - loss=0.74093616, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50658929, MSE_maskV_-1.0=0.74063283, val_loss=0.74845099, val_CC_maskV_-1.0=0.5026381, val_MSE_maskV_-1.0=0.74700058, learning_rate=0.001\n", + "Epoch 89/106 - loss=0.73967367, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50841224, MSE_maskV_-1.0=0.74083632, val_loss=0.74494374, val_CC_maskV_-1.0=0.50538617, val_MSE_maskV_-1.0=0.74355459, learning_rate=0.001\n", + "Epoch 100/106 - loss=0.73880923, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50932276, MSE_maskV_-1.0=0.73840779, val_loss=0.74497354, val_CC_maskV_-1.0=0.50530577, val_MSE_maskV_-1.0=0.74360693, learning_rate=0.001\n", + "Epoch 106/106 - loss=0.73873681, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50948054, MSE_maskV_-1.0=0.73808956, val_loss=0.74378949, val_CC_maskV_-1.0=0.50661659, val_MSE_maskV_-1.0=0.74228424, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:34:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 26.62s\n", + "\u001b[32m2025-05-30 10:34:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.74167764)\n", + "\u001b[32m2025-05-30 10:34:55\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 766us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:34:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.737, R2_maskV_-1.0=0.265, CC_maskV_-1.0=0.513\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 791us/step\n", + "51/51 [==============================] - 0s 789us/step\n", + "84/84 [==============================] - 0s 740us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:34:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_A1HL64U_ErSV16\" (2/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_A1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 10:34:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_K1HL64U_ErSV16\" (3/16)\n", + "\u001b[32m2025-05-30 10:34:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_K1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 10:34:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 10:34:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 10:34:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 10:34:56\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 10:34:56\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 10:34:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:35:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 82 (stopped at 97 epochs).\n", + "\u001b[32m2025-05-30 10:35:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/98 - loss=rnn_1step_loss=0.99922806, rnn_1step_R2_maskV_-1.0=-0.022122048, rnn_1step_CC_maskV_-1.0=0.020918023, rnn_1step_MSE_maskV_-1.0=0.99922812, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96576571, val_rnn_1step_R2_maskV_-1.0=-0.088779882, val_rnn_1step_CC_maskV_-1.0=0.14824842, learning_rate=0.001\n", + "Epoch 11/98 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.85046816, rnn_1step_R2_maskV_-1.0=0.12800808, rnn_1step_CC_maskV_-1.0=0.39166543, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.83126289, val_rnn_1step_R2_maskV_-1.0=0.049576312, val_rnn_1step_CC_maskV_-1.0=0.38665295, learning_rate=0.001\n", + "Epoch 21/98 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.6291545, rnn_1step_R2_maskV_-1.0=0.34568238, rnn_1step_CC_maskV_-1.0=0.60933602, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6794858, val_rnn_1step_R2_maskV_-1.0=0.22332583, val_rnn_1step_CC_maskV_-1.0=0.55475152, learning_rate=0.001\n", + "Epoch 31/98 - loss=rnn_1step_loss=0.53161079, rnn_1step_R2_maskV_-1.0=0.448239, rnn_1step_CC_maskV_-1.0=0.6837368, rnn_1step_MSE_maskV_-1.0=0.53161073, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63358104, val_rnn_1step_R2_maskV_-1.0=0.27887768, val_rnn_1step_CC_maskV_-1.0=0.59442496, learning_rate=0.001\n", + "Epoch 41/98 - loss=rnn_1step_loss=0.45508337, rnn_1step_R2_maskV_-1.0=0.52874148, rnn_1step_CC_maskV_-1.0=0.73707962, rnn_1step_MSE_maskV_-1.0=0.45508334, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5828287, val_rnn_1step_R2_maskV_-1.0=0.33911803, val_rnn_1step_CC_maskV_-1.0=0.63396811, learning_rate=0.001\n", + "Epoch 51/98 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38050756, rnn_1step_R2_maskV_-1.0=0.60643685, rnn_1step_CC_maskV_-1.0=0.78604174, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52504581, val_rnn_1step_R2_maskV_-1.0=0.40296277, val_rnn_1step_CC_maskV_-1.0=0.68089575, learning_rate=0.001\n", + "Epoch 61/98 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31892556, rnn_1step_R2_maskV_-1.0=0.66959143, rnn_1step_CC_maskV_-1.0=0.82430899, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48961559, val_rnn_1step_R2_maskV_-1.0=0.4429554, val_rnn_1step_CC_maskV_-1.0=0.71160245, learning_rate=0.001\n", + "Epoch 71/98 - loss=rnn_1step_loss=0.28435257, rnn_1step_R2_maskV_-1.0=0.70556843, rnn_1step_CC_maskV_-1.0=0.84477216, rnn_1step_MSE_maskV_-1.0=0.2843526, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4763439, val_rnn_1step_R2_maskV_-1.0=0.45814833, val_rnn_1step_CC_maskV_-1.0=0.72529835, learning_rate=0.001\n", + "Epoch 81/98 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.26709715, rnn_1step_R2_maskV_-1.0=0.72359747, rnn_1step_CC_maskV_-1.0=0.85472882, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4732438, val_rnn_1step_R2_maskV_-1.0=0.46135658, val_rnn_1step_CC_maskV_-1.0=0.73053801, learning_rate=0.001\n", + "Epoch 91/98 - loss=rnn_1step_loss=0.25315192, rnn_1step_R2_maskV_-1.0=0.7380529, rnn_1step_CC_maskV_-1.0=0.86286604, rnn_1step_MSE_maskV_-1.0=0.25315195, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47473815, val_rnn_1step_R2_maskV_-1.0=0.45975536, val_rnn_1step_CC_maskV_-1.0=0.72950441, learning_rate=0.001\n", + "Epoch 98/98 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.24459536, rnn_1step_R2_maskV_-1.0=0.74695611, rnn_1step_CC_maskV_-1.0=0.86786067, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4741056, val_rnn_1step_R2_maskV_-1.0=0.46112072, val_rnn_1step_CC_maskV_-1.0=0.73129743, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:35:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 11.70s\n", + "\u001b[32m2025-05-30 10:35:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:35:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 64 (stopped at 79 epochs).\n", + "\u001b[32m2025-05-30 10:35:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/80 - loss=rnn_1_1step_loss=0.99867553, rnn_1_1step_R2_maskV_-1.0=-0.021594945, rnn_1_1step_CC_maskV_-1.0=0.10225876, rnn_1_1step_MSE_maskV_-1.0=0.99867547, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96531892, val_rnn_1_1step_R2_maskV_-1.0=-0.088197008, val_rnn_1_1step_CC_maskV_-1.0=0.14999549, learning_rate=0.001\n", + "Epoch 9/80 - loss=rnn_1_1step_loss=0.90423757, rnn_1_1step_R2_maskV_-1.0=0.074046627, rnn_1_1step_CC_maskV_-1.0=0.44882584, rnn_1_1step_MSE_maskV_-1.0=0.90423763, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.86402768, val_rnn_1_1step_R2_maskV_-1.0=0.024072826, val_rnn_1_1step_CC_maskV_-1.0=0.41499817, learning_rate=0.001\n", + "Epoch 17/80 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.66712499, rnn_1_1step_R2_maskV_-1.0=0.30942762, rnn_1_1step_CC_maskV_-1.0=0.577416, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.69458026, val_rnn_1_1step_R2_maskV_-1.0=0.20687221, val_rnn_1_1step_CC_maskV_-1.0=0.54837888, learning_rate=0.001\n", + "Epoch 25/80 - loss=rnn_1_1step_loss=0.56466216, rnn_1_1step_R2_maskV_-1.0=0.41453782, rnn_1_1step_CC_maskV_-1.0=0.65984195, rnn_1_1step_MSE_maskV_-1.0=0.5646621, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63274211, val_rnn_1_1step_R2_maskV_-1.0=0.27429643, val_rnn_1_1step_CC_maskV_-1.0=0.6012845, learning_rate=0.001\n", + "Epoch 33/80 - loss=rnn_1_1step_loss=0.48779032, rnn_1_1step_R2_maskV_-1.0=0.49448949, rnn_1_1step_CC_maskV_-1.0=0.71528727, rnn_1_1step_MSE_maskV_-1.0=0.48779026, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58865786, val_rnn_1_1step_R2_maskV_-1.0=0.32638478, val_rnn_1_1step_CC_maskV_-1.0=0.63645774, learning_rate=0.001\n", + "Epoch 41/80 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.4194316, rnn_1_1step_R2_maskV_-1.0=0.56542766, rnn_1_1step_CC_maskV_-1.0=0.76178062, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55327785, val_rnn_1_1step_R2_maskV_-1.0=0.36861694, val_rnn_1_1step_CC_maskV_-1.0=0.66668963, learning_rate=0.001\n", + "Epoch 49/80 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36023465, rnn_1_1step_R2_maskV_-1.0=0.62777036, rnn_1_1step_CC_maskV_-1.0=0.79919958, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51576179, val_rnn_1_1step_R2_maskV_-1.0=0.41261643, val_rnn_1_1step_CC_maskV_-1.0=0.69354373, learning_rate=0.001\n", + "Epoch 57/80 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31830484, rnn_1_1step_R2_maskV_-1.0=0.67232281, rnn_1_1step_CC_maskV_-1.0=0.82455742, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48150858, val_rnn_1_1step_R2_maskV_-1.0=0.45145386, val_rnn_1_1step_CC_maskV_-1.0=0.7178269, learning_rate=0.001\n", + "Epoch 65/80 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30001247, rnn_1_1step_R2_maskV_-1.0=0.69133866, rnn_1_1step_CC_maskV_-1.0=0.83542496, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47618163, val_rnn_1_1step_R2_maskV_-1.0=0.45720607, val_rnn_1_1step_CC_maskV_-1.0=0.72316438, learning_rate=0.001\n", + "Epoch 73/80 - loss=rnn_1_1step_loss=0.28689137, rnn_1_1step_R2_maskV_-1.0=0.70489365, rnn_1_1step_CC_maskV_-1.0=0.84319937, rnn_1_1step_MSE_maskV_-1.0=0.2868914, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47971025, val_rnn_1_1step_R2_maskV_-1.0=0.45295191, val_rnn_1_1step_CC_maskV_-1.0=0.7219677, learning_rate=0.001\n", + "Epoch 80/80 - loss=rnn_1_1step_loss=0.27726686, rnn_1_1step_R2_maskV_-1.0=0.71474743, rnn_1_1step_CC_maskV_-1.0=0.84887213, rnn_1_1step_MSE_maskV_-1.0=0.27726689, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48304495, val_rnn_1_1step_R2_maskV_-1.0=0.44900066, val_rnn_1_1step_CC_maskV_-1.0=0.72054517, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:35:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 9.76s\n", + "\u001b[32m2025-05-30 10:35:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.46283606)\n", + "\u001b[32m2025-05-30 10:35:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.223, R2_maskV_-1.0=0.777, CC_maskV_-1.0=0.882\n", + "\u001b[32m2025-05-30 10:35:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.431, R2_maskV_-1.0=0.525, CC_maskV_-1.0=0.757\n", + "\u001b[32m2025-05-30 10:35:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 10:35:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:36:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 295 (stopped at 310 epochs).\n", + "\u001b[32m2025-05-30 10:36:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/311 - loss=1.9205717, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.025462009, MSE_maskV_-1.0=1.9198862, val_loss=1.164264, val_CC_maskV_-1.0=0.065452203, val_MSE_maskV_-1.0=1.1599005, learning_rate=0.001\n", + "Epoch 33/311 - loss=0.89437038, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.33200279, MSE_maskV_-1.0=0.89391726, val_loss=0.89978665, val_CC_maskV_-1.0=0.34176186, val_MSE_maskV_-1.0=0.89705825, learning_rate=0.001\n", + "Epoch 65/311 - loss=0.86307639, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37786618, MSE_maskV_-1.0=0.86363304, val_loss=0.87133789, val_CC_maskV_-1.0=0.37693319, val_MSE_maskV_-1.0=0.86916286, learning_rate=0.001\n", + "Epoch 97/311 - loss=0.84758353, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3955324, MSE_maskV_-1.0=0.84672219, val_loss=0.85215867, val_CC_maskV_-1.0=0.40125284, val_MSE_maskV_-1.0=0.84932011, learning_rate=0.001\n", + "Epoch 129/311 - loss=0.83761394, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4072192, MSE_maskV_-1.0=0.83724856, val_loss=0.84390444, val_CC_maskV_-1.0=0.40821579, val_MSE_maskV_-1.0=0.84139013, learning_rate=0.001\n", + "Epoch 161/311 - loss=0.83083087, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41435015, MSE_maskV_-1.0=0.83078444, val_loss=0.83875602, val_CC_maskV_-1.0=0.41264641, val_MSE_maskV_-1.0=0.83611125, learning_rate=0.001\n", + "Epoch 193/311 - loss=0.82546401, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42101318, MSE_maskV_-1.0=0.8246935, val_loss=0.83197033, val_CC_maskV_-1.0=0.42123365, val_MSE_maskV_-1.0=0.82953465, learning_rate=0.001\n", + "Epoch 225/311 - loss=0.82115698, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42551059, MSE_maskV_-1.0=0.82166529, val_loss=0.82780808, val_CC_maskV_-1.0=0.42470312, val_MSE_maskV_-1.0=0.82566071, learning_rate=0.001\n", + "Epoch 257/311 - loss=0.81762993, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4290143, MSE_maskV_-1.0=0.81683618, val_loss=0.82588696, val_CC_maskV_-1.0=0.42667899, val_MSE_maskV_-1.0=0.8240186, learning_rate=0.001\n", + "Epoch 289/311 - loss=0.81425601, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.433292, MSE_maskV_-1.0=0.81401002, val_loss=0.82136452, val_CC_maskV_-1.0=0.43216774, val_MSE_maskV_-1.0=0.81907809, learning_rate=0.001\n", + "Epoch 311/311 - loss=0.81277341, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43430296, MSE_maskV_-1.0=0.81577069, val_loss=0.82093483, val_CC_maskV_-1.0=0.43234658, val_MSE_maskV_-1.0=0.81862378, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:36:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 76.00s\n", + "\u001b[32m2025-05-30 10:36:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:37:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 295 (stopped at 310 epochs).\n", + "\u001b[32m2025-05-30 10:37:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/311 - loss=2.2261302, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.013887983, MSE_maskV_-1.0=2.2243915, val_loss=1.1574476, val_CC_maskV_-1.0=0.046511784, val_MSE_maskV_-1.0=1.1531506, learning_rate=0.001\n", + "Epoch 33/311 - loss=0.89909017, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.32396924, MSE_maskV_-1.0=0.89863217, val_loss=0.90264767, val_CC_maskV_-1.0=0.33610258, val_MSE_maskV_-1.0=0.89987534, learning_rate=0.001\n", + "Epoch 65/311 - loss=0.86499906, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37554905, MSE_maskV_-1.0=0.8655349, val_loss=0.8722828, val_CC_maskV_-1.0=0.37569061, val_MSE_maskV_-1.0=0.86999816, learning_rate=0.001\n", + "Epoch 97/311 - loss=0.84852433, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39447311, MSE_maskV_-1.0=0.84767532, val_loss=0.8523857, val_CC_maskV_-1.0=0.40097401, val_MSE_maskV_-1.0=0.84942544, learning_rate=0.001\n", + "Epoch 129/311 - loss=0.83821708, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40651333, MSE_maskV_-1.0=0.83785826, val_loss=0.84396225, val_CC_maskV_-1.0=0.40819061, val_MSE_maskV_-1.0=0.84130281, learning_rate=0.001\n", + "Epoch 161/311 - loss=0.8312664, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41383061, MSE_maskV_-1.0=0.831218, val_loss=0.83868206, val_CC_maskV_-1.0=0.41273981, val_MSE_maskV_-1.0=0.83596045, learning_rate=0.001\n", + "Epoch 193/311 - loss=0.8258459, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42057732, MSE_maskV_-1.0=0.82506818, val_loss=0.8320266, val_CC_maskV_-1.0=0.42121521, val_MSE_maskV_-1.0=0.82944959, learning_rate=0.001\n", + "Epoch 225/311 - loss=0.82149023, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42509249, MSE_maskV_-1.0=0.82201779, val_loss=0.82789713, val_CC_maskV_-1.0=0.424604, val_MSE_maskV_-1.0=0.82563162, learning_rate=0.001\n", + "Epoch 257/311 - loss=0.8179273, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42866296, MSE_maskV_-1.0=0.81713063, val_loss=0.82598341, val_CC_maskV_-1.0=0.42662165, val_MSE_maskV_-1.0=0.82402498, learning_rate=0.001\n", + "Epoch 289/311 - loss=0.81453747, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4329558, MSE_maskV_-1.0=0.8142913, val_loss=0.82146162, val_CC_maskV_-1.0=0.43211398, val_MSE_maskV_-1.0=0.81907833, learning_rate=0.001\n", + "Epoch 311/311 - loss=0.81303513, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43396235, MSE_maskV_-1.0=0.81603622, val_loss=0.8210029, val_CC_maskV_-1.0=0.43233255, val_MSE_maskV_-1.0=0.81860399, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:37:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 76.45s\n", + "\u001b[32m2025-05-30 10:37:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.8183372)\n", + "\u001b[32m2025-05-30 10:37:52\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 783us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:37:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.813, R2_maskV_-1.0=0.187, CC_maskV_-1.0=0.433\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 771us/step\n", + "51/51 [==============================] - 0s 816us/step\n", + "84/84 [==============================] - 0s 767us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:37:53\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_K1HL64U_ErSV16\" (3/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_K1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 10:37:53\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_Cz1HL64U_ErSV16\" (4/16)\n", + "\u001b[32m2025-05-30 10:37:53\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_Cz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 10:37:53\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 10:37:53\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 10:37:53\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 10:37:53\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 10:37:53\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 10:37:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:38:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 287 (stopped at 302 epochs).\n", + "\u001b[32m2025-05-30 10:38:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/303 - loss=rnn_1step_loss=0.99874336, rnn_1step_R2_maskV_-1.0=-0.021688983, rnn_1step_CC_maskV_-1.0=0.092986867, rnn_1step_MSE_maskV_-1.0=0.99874341, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96462107, val_rnn_1step_R2_maskV_-1.0=-0.08744891, val_rnn_1step_CC_maskV_-1.0=0.18932818, learning_rate=0.001\n", + "Epoch 32/303 - loss=rnn_1step_loss=0.57140487, rnn_1step_R2_maskV_-1.0=0.40824473, rnn_1step_CC_maskV_-1.0=0.65403789, rnn_1step_MSE_maskV_-1.0=0.57140481, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63877815, val_rnn_1step_R2_maskV_-1.0=0.27112049, val_rnn_1step_CC_maskV_-1.0=0.58682019, learning_rate=0.001\n", + "Epoch 63/303 - loss=rnn_1step_loss=0.44652405, rnn_1step_R2_maskV_-1.0=0.53872138, rnn_1step_CC_maskV_-1.0=0.74217594, rnn_1step_MSE_maskV_-1.0=0.44652408, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55822492, val_rnn_1step_R2_maskV_-1.0=0.35896337, val_rnn_1step_CC_maskV_-1.0=0.66280156, learning_rate=0.001\n", + "Epoch 94/303 - loss=rnn_1step_loss=0.41383076, rnn_1step_R2_maskV_-1.0=0.57238561, rnn_1step_CC_maskV_-1.0=0.76392394, rnn_1step_MSE_maskV_-1.0=0.41383079, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53330034, val_rnn_1step_R2_maskV_-1.0=0.38664928, val_rnn_1step_CC_maskV_-1.0=0.67949432, learning_rate=0.001\n", + "Epoch 125/303 - loss=rnn_1step_loss=0.39591169, rnn_1step_R2_maskV_-1.0=0.59090668, rnn_1step_CC_maskV_-1.0=0.77579123, rnn_1step_MSE_maskV_-1.0=0.39591172, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52328426, val_rnn_1step_R2_maskV_-1.0=0.39842844, val_rnn_1step_CC_maskV_-1.0=0.68734866, learning_rate=0.001\n", + "Epoch 156/303 - loss=rnn_1step_loss=0.377473, rnn_1step_R2_maskV_-1.0=0.60981774, rnn_1step_CC_maskV_-1.0=0.7878316, rnn_1step_MSE_maskV_-1.0=0.37747297, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51307631, val_rnn_1step_R2_maskV_-1.0=0.41027522, val_rnn_1step_CC_maskV_-1.0=0.69677734, learning_rate=0.001\n", + "Epoch 187/303 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35625204, rnn_1step_R2_maskV_-1.0=0.63151866, rnn_1step_CC_maskV_-1.0=0.8013553, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50376219, val_rnn_1step_R2_maskV_-1.0=0.42064035, val_rnn_1step_CC_maskV_-1.0=0.70676309, learning_rate=0.001\n", + "Epoch 218/303 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33998594, rnn_1step_R2_maskV_-1.0=0.64833677, rnn_1step_CC_maskV_-1.0=0.81152183, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49709344, val_rnn_1step_R2_maskV_-1.0=0.42822641, val_rnn_1step_CC_maskV_-1.0=0.71277523, learning_rate=0.001\n", + "Epoch 249/303 - loss=rnn_1step_loss=0.32974666, rnn_1step_R2_maskV_-1.0=0.65897864, rnn_1step_CC_maskV_-1.0=0.81773907, rnn_1step_MSE_maskV_-1.0=0.32974669, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49465334, val_rnn_1step_R2_maskV_-1.0=0.43135098, val_rnn_1step_CC_maskV_-1.0=0.71624345, learning_rate=0.001\n", + "Epoch 280/303 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32143897, rnn_1step_R2_maskV_-1.0=0.66756284, rnn_1step_CC_maskV_-1.0=0.82276475, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49376202, val_rnn_1step_R2_maskV_-1.0=0.4326809, val_rnn_1step_CC_maskV_-1.0=0.71776301, learning_rate=0.001\n", + "Epoch 303/303 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31598914, rnn_1step_R2_maskV_-1.0=0.67318904, rnn_1step_CC_maskV_-1.0=0.82602203, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49478492, val_rnn_1step_R2_maskV_-1.0=0.43181729, val_rnn_1step_CC_maskV_-1.0=0.71816033, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:38:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 31.40s\n", + "\u001b[32m2025-05-30 10:38:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:38:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 239 (stopped at 254 epochs).\n", + "\u001b[32m2025-05-30 10:38:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/255 - loss=rnn_1_1step_loss=0.99951673, rnn_1_1step_R2_maskV_-1.0=-0.022429369, rnn_1_1step_CC_maskV_-1.0=0.0013596788, rnn_1_1step_MSE_maskV_-1.0=0.99951679, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96453577, val_rnn_1_1step_R2_maskV_-1.0=-0.087272227, val_rnn_1_1step_CC_maskV_-1.0=0.18087305, learning_rate=0.001\n", + "Epoch 27/255 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.6018253, rnn_1_1step_R2_maskV_-1.0=0.37751698, rnn_1_1step_CC_maskV_-1.0=0.6296258, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.67369723, val_rnn_1_1step_R2_maskV_-1.0=0.23133846, val_rnn_1_1step_CC_maskV_-1.0=0.56249791, learning_rate=0.001\n", + "Epoch 53/255 - loss=rnn_1_1step_loss=0.45942917, rnn_1_1step_R2_maskV_-1.0=0.52457607, rnn_1_1step_CC_maskV_-1.0=0.7335881, rnn_1_1step_MSE_maskV_-1.0=0.4594292, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57040906, val_rnn_1_1step_R2_maskV_-1.0=0.34699345, val_rnn_1_1step_CC_maskV_-1.0=0.65275472, learning_rate=0.001\n", + "Epoch 79/255 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41859007, rnn_1_1step_R2_maskV_-1.0=0.5663622, rnn_1_1step_CC_maskV_-1.0=0.76099092, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54243642, val_rnn_1_1step_R2_maskV_-1.0=0.37690222, val_rnn_1_1step_CC_maskV_-1.0=0.6742, learning_rate=0.001\n", + "Epoch 105/255 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38981423, rnn_1_1step_R2_maskV_-1.0=0.59624308, rnn_1_1step_CC_maskV_-1.0=0.77995741, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53273553, val_rnn_1_1step_R2_maskV_-1.0=0.38810945, val_rnn_1_1step_CC_maskV_-1.0=0.68163383, learning_rate=0.001\n", + "Epoch 131/255 - loss=rnn_1_1step_loss=0.36456966, rnn_1_1step_R2_maskV_-1.0=0.62259305, rnn_1_1step_CC_maskV_-1.0=0.796049, rnn_1_1step_MSE_maskV_-1.0=0.36456969, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52290386, val_rnn_1_1step_R2_maskV_-1.0=0.39940864, val_rnn_1_1step_CC_maskV_-1.0=0.69122648, learning_rate=0.001\n", + "Epoch 157/255 - loss=rnn_1_1step_loss=0.35187519, rnn_1_1step_R2_maskV_-1.0=0.63592851, rnn_1_1step_CC_maskV_-1.0=0.80383825, rnn_1_1step_MSE_maskV_-1.0=0.35187516, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51921839, val_rnn_1_1step_R2_maskV_-1.0=0.40306547, val_rnn_1_1step_CC_maskV_-1.0=0.69688505, learning_rate=0.001\n", + "Epoch 183/255 - loss=rnn_1_1step_loss=0.3448548, rnn_1_1step_R2_maskV_-1.0=0.64325494, rnn_1_1step_CC_maskV_-1.0=0.80813783, rnn_1_1step_MSE_maskV_-1.0=0.34485477, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51665974, val_rnn_1_1step_R2_maskV_-1.0=0.40567467, val_rnn_1_1step_CC_maskV_-1.0=0.70069593, learning_rate=0.001\n", + "Epoch 209/255 - loss=rnn_1_1step_loss=0.3389121, rnn_1_1step_R2_maskV_-1.0=0.64942533, rnn_1_1step_CC_maskV_-1.0=0.81184161, rnn_1_1step_MSE_maskV_-1.0=0.33891213, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5153423, val_rnn_1_1step_R2_maskV_-1.0=0.40697044, val_rnn_1_1step_CC_maskV_-1.0=0.70272624, learning_rate=0.001\n", + "Epoch 235/255 - loss=rnn_1_1step_loss=0.33403245, rnn_1_1step_R2_maskV_-1.0=0.65438557, rnn_1_1step_CC_maskV_-1.0=0.81469923, rnn_1_1step_MSE_maskV_-1.0=0.33403248, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51638097, val_rnn_1_1step_R2_maskV_-1.0=0.40574187, val_rnn_1_1step_CC_maskV_-1.0=0.70426577, learning_rate=0.001\n", + "Epoch 255/255 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32936069, rnn_1_1step_R2_maskV_-1.0=0.6592319, rnn_1_1step_CC_maskV_-1.0=0.81775641, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51525706, val_rnn_1_1step_R2_maskV_-1.0=0.40703323, val_rnn_1_1step_CC_maskV_-1.0=0.70516938, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:38:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 26.23s\n", + "\u001b[32m2025-05-30 10:38:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.49357221)\n", + "\u001b[32m2025-05-30 10:38:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.286, R2_maskV_-1.0=0.714, CC_maskV_-1.0=0.845\n", + "\u001b[32m2025-05-30 10:38:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.461, R2_maskV_-1.0=0.483, CC_maskV_-1.0=0.743\n", + "\u001b[32m2025-05-30 10:38:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 10:38:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:39:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 193 (stopped at 208 epochs).\n", + "\u001b[32m2025-05-30 10:39:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/209 - loss=7.1039858, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.018993558, MSE_maskV_-1.0=7.090239, val_loss=1.9062957, val_CC_maskV_-1.0=0.054316912, val_MSE_maskV_-1.0=1.895164, learning_rate=0.001\n", + "Epoch 22/209 - loss=0.81050718, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43494183, MSE_maskV_-1.0=0.81102878, val_loss=0.81555831, val_CC_maskV_-1.0=0.43288887, val_MSE_maskV_-1.0=0.81381023, learning_rate=0.001\n", + "Epoch 43/209 - loss=0.76436341, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48490837, MSE_maskV_-1.0=0.76442862, val_loss=0.77351195, val_CC_maskV_-1.0=0.47861975, val_MSE_maskV_-1.0=0.77161533, learning_rate=0.001\n", + "Epoch 64/209 - loss=0.74339718, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5063951, MSE_maskV_-1.0=0.74330592, val_loss=0.75308132, val_CC_maskV_-1.0=0.49907503, val_MSE_maskV_-1.0=0.75124443, learning_rate=0.001\n", + "Epoch 85/209 - loss=0.73139602, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51759326, MSE_maskV_-1.0=0.73143911, val_loss=0.73954803, val_CC_maskV_-1.0=0.51175714, val_MSE_maskV_-1.0=0.7376551, learning_rate=0.001\n", + "Epoch 106/209 - loss=0.72366577, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52463996, MSE_maskV_-1.0=0.72307855, val_loss=0.73401397, val_CC_maskV_-1.0=0.51624954, val_MSE_maskV_-1.0=0.73239523, learning_rate=0.001\n", + "Epoch 127/209 - loss=0.7182669, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52901328, MSE_maskV_-1.0=0.71966749, val_loss=0.7273016, val_CC_maskV_-1.0=0.52331865, val_MSE_maskV_-1.0=0.72526765, learning_rate=0.001\n", + "Epoch 148/209 - loss=0.71567059, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53231418, MSE_maskV_-1.0=0.71733195, val_loss=0.72233826, val_CC_maskV_-1.0=0.52668136, val_MSE_maskV_-1.0=0.72055781, learning_rate=0.001\n", + "Epoch 169/209 - loss=0.71283436, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53509796, MSE_maskV_-1.0=0.71283489, val_loss=0.72022581, val_CC_maskV_-1.0=0.52782691, val_MSE_maskV_-1.0=0.71831399, learning_rate=0.001\n", + "Epoch 190/209 - loss=0.71230614, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53450584, MSE_maskV_-1.0=0.71208912, val_loss=0.72110033, val_CC_maskV_-1.0=0.52715939, val_MSE_maskV_-1.0=0.71937507, learning_rate=0.001\n", + "Epoch 209/209 - loss=0.71121103, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53669465, MSE_maskV_-1.0=0.7106241, val_loss=0.71770412, val_CC_maskV_-1.0=0.53107268, val_MSE_maskV_-1.0=0.71618807, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:39:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 51.78s\n", + "\u001b[32m2025-05-30 10:39:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:40:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 193 (stopped at 208 epochs).\n", + "\u001b[32m2025-05-30 10:40:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/209 - loss=9.6985531, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0074705128, MSE_maskV_-1.0=9.6757736, val_loss=1.9396521, val_CC_maskV_-1.0=0.058240309, val_MSE_maskV_-1.0=1.9322726, learning_rate=0.001\n", + "Epoch 22/209 - loss=0.80961657, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43576965, MSE_maskV_-1.0=0.81002587, val_loss=0.82130635, val_CC_maskV_-1.0=0.42695674, val_MSE_maskV_-1.0=0.81973922, learning_rate=0.001\n", + "Epoch 43/209 - loss=0.76543456, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4836978, MSE_maskV_-1.0=0.76551962, val_loss=0.77904153, val_CC_maskV_-1.0=0.47311383, val_MSE_maskV_-1.0=0.77727234, learning_rate=0.001\n", + "Epoch 64/209 - loss=0.7441839, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50560266, MSE_maskV_-1.0=0.74411756, val_loss=0.7581563, val_CC_maskV_-1.0=0.49443719, val_MSE_maskV_-1.0=0.7562955, learning_rate=0.001\n", + "Epoch 85/209 - loss=0.73207462, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5169273, MSE_maskV_-1.0=0.73213416, val_loss=0.74303156, val_CC_maskV_-1.0=0.50861609, val_MSE_maskV_-1.0=0.74121004, learning_rate=0.001\n", + "Epoch 106/209 - loss=0.72421247, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52408594, MSE_maskV_-1.0=0.72363925, val_loss=0.73759025, val_CC_maskV_-1.0=0.51319438, val_MSE_maskV_-1.0=0.73591524, learning_rate=0.001\n", + "Epoch 127/209 - loss=0.7186836, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52868283, MSE_maskV_-1.0=0.72008383, val_loss=0.72991604, val_CC_maskV_-1.0=0.52110916, val_MSE_maskV_-1.0=0.72786117, learning_rate=0.001\n", + "Epoch 148/209 - loss=0.71597111, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53207886, MSE_maskV_-1.0=0.71757001, val_loss=0.72456264, val_CC_maskV_-1.0=0.52482444, val_MSE_maskV_-1.0=0.7227596, learning_rate=0.001\n", + "Epoch 169/209 - loss=0.71303982, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53490502, MSE_maskV_-1.0=0.71303731, val_loss=0.72197598, val_CC_maskV_-1.0=0.52639073, val_MSE_maskV_-1.0=0.72004873, learning_rate=0.001\n", + "Epoch 190/209 - loss=0.71250659, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53431678, MSE_maskV_-1.0=0.71228647, val_loss=0.72232825, val_CC_maskV_-1.0=0.52616543, val_MSE_maskV_-1.0=0.72058487, learning_rate=0.001\n", + "Epoch 209/209 - loss=0.7113291, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53657693, MSE_maskV_-1.0=0.71073723, val_loss=0.71900821, val_CC_maskV_-1.0=0.52994347, val_MSE_maskV_-1.0=0.71750659, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:40:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 51.75s\n", + "\u001b[32m2025-05-30 10:40:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.71523649)\n", + "\u001b[32m2025-05-30 10:40:36\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 776us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:40:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.708, R2_maskV_-1.0=0.293, CC_maskV_-1.0=0.54\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 791us/step\n", + "51/51 [==============================] - 0s 813us/step\n", + "84/84 [==============================] - 0s 707us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:40:37\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_Cz1HL64U_ErSV16\" (4/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_Cz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 10:40:37\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_Cy1HL64U_ErSV16\" (5/16)\n", + "\u001b[32m2025-05-30 10:40:37\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_Cy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 10:40:37\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 10:40:37\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 10:40:37\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 10:40:37\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 10:40:37\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 10:40:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:43:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 2024 (stopped at 2039 epochs).\n", + "\u001b[32m2025-05-30 10:43:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/2040 - loss=rnn_1step_loss=0.99258012, rnn_1step_R2_maskV_-1.0=-0.01547325, rnn_1step_CC_maskV_-1.0=0.15862116, rnn_1step_MSE_maskV_-1.0=0.99258, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.959786, val_rnn_1step_R2_maskV_-1.0=-0.081886128, val_rnn_1step_CC_maskV_-1.0=0.17300364, learning_rate=0.001\n", + "Epoch 205/2040 - loss=rnn_1step_loss=0.42330185, rnn_1step_R2_maskV_-1.0=0.56345344, rnn_1step_CC_maskV_-1.0=0.75758302, rnn_1step_MSE_maskV_-1.0=0.42330188, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53526825, val_rnn_1step_R2_maskV_-1.0=0.38669157, val_rnn_1step_CC_maskV_-1.0=0.68332928, learning_rate=0.001\n", + "Epoch 409/2040 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41557923, rnn_1step_R2_maskV_-1.0=0.57106, rnn_1step_CC_maskV_-1.0=0.76278043, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53271341, val_rnn_1step_R2_maskV_-1.0=0.38958442, val_rnn_1step_CC_maskV_-1.0=0.6863507, learning_rate=0.001\n", + "Epoch 613/2040 - loss=rnn_1step_loss=0.40915957, rnn_1step_R2_maskV_-1.0=0.57732773, rnn_1step_CC_maskV_-1.0=0.76706064, rnn_1step_MSE_maskV_-1.0=0.4091596, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52911633, val_rnn_1step_R2_maskV_-1.0=0.39381304, val_rnn_1step_CC_maskV_-1.0=0.68908072, learning_rate=0.001\n", + "Epoch 817/2040 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4071362, rnn_1step_R2_maskV_-1.0=0.57939804, rnn_1step_CC_maskV_-1.0=0.76837367, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52839953, val_rnn_1step_R2_maskV_-1.0=0.39458394, val_rnn_1step_CC_maskV_-1.0=0.68961358, learning_rate=0.001\n", + "Epoch 1021/2040 - loss=rnn_1step_loss=0.40599707, rnn_1step_R2_maskV_-1.0=0.58061022, rnn_1step_CC_maskV_-1.0=0.76910967, rnn_1step_MSE_maskV_-1.0=0.4059971, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52704078, val_rnn_1step_R2_maskV_-1.0=0.39605933, val_rnn_1step_CC_maskV_-1.0=0.69079351, learning_rate=0.001\n", + "Epoch 1225/2040 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40510067, rnn_1step_R2_maskV_-1.0=0.58154261, rnn_1step_CC_maskV_-1.0=0.76970309, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52541679, val_rnn_1step_R2_maskV_-1.0=0.39789999, val_rnn_1step_CC_maskV_-1.0=0.69217604, learning_rate=0.001\n", + "Epoch 1429/2040 - loss=rnn_1step_loss=0.40460005, rnn_1step_R2_maskV_-1.0=0.58206999, rnn_1step_CC_maskV_-1.0=0.77005422, rnn_1step_MSE_maskV_-1.0=0.40460008, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52419394, val_rnn_1step_R2_maskV_-1.0=0.39931419, val_rnn_1step_CC_maskV_-1.0=0.69321656, learning_rate=0.001\n", + "Epoch 1633/2040 - loss=rnn_1step_loss=0.40436637, rnn_1step_R2_maskV_-1.0=0.58232862, rnn_1step_CC_maskV_-1.0=0.77023578, rnn_1step_MSE_maskV_-1.0=0.4043664, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5233255, val_rnn_1step_R2_maskV_-1.0=0.40034467, val_rnn_1step_CC_maskV_-1.0=0.69400918, learning_rate=0.001\n", + "Epoch 1837/2040 - loss=rnn_1step_loss=0.40418577, rnn_1step_R2_maskV_-1.0=0.58253109, rnn_1step_CC_maskV_-1.0=0.77038294, rnn_1step_MSE_maskV_-1.0=0.4041858, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52275544, val_rnn_1step_R2_maskV_-1.0=0.40104002, val_rnn_1step_CC_maskV_-1.0=0.69458097, learning_rate=0.001\n", + "Epoch 2040/2040 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40415886, rnn_1step_R2_maskV_-1.0=0.58257008, rnn_1step_CC_maskV_-1.0=0.77043223, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52254385, val_rnn_1step_R2_maskV_-1.0=0.40132287, val_rnn_1step_CC_maskV_-1.0=0.69478965, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:43:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 197.04s\n", + "\u001b[32m2025-05-30 10:43:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:44:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 139 (stopped at 154 epochs).\n", + "\u001b[32m2025-05-30 10:44:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/155 - loss=rnn_1_1step_loss=0.99550742, rnn_1_1step_R2_maskV_-1.0=-0.018401135, rnn_1_1step_CC_maskV_-1.0=0.095601737, rnn_1_1step_MSE_maskV_-1.0=0.9955073, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.959171, val_rnn_1_1step_R2_maskV_-1.0=-0.08122465, val_rnn_1_1step_CC_maskV_-1.0=0.17166778, learning_rate=0.001\n", + "Epoch 17/155 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.72192115, rnn_1_1step_R2_maskV_-1.0=0.2579667, rnn_1_1step_CC_maskV_-1.0=0.52865005, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.73939443, val_rnn_1_1step_R2_maskV_-1.0=0.15953073, val_rnn_1_1step_CC_maskV_-1.0=0.49825683, learning_rate=0.001\n", + "Epoch 33/155 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.57437015, rnn_1_1step_R2_maskV_-1.0=0.40745735, rnn_1_1step_CC_maskV_-1.0=0.65246648, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6395216, val_rnn_1_1step_R2_maskV_-1.0=0.26853037, val_rnn_1_1step_CC_maskV_-1.0=0.59461379, learning_rate=0.001\n", + "Epoch 49/155 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.51398182, rnn_1_1step_R2_maskV_-1.0=0.47042182, rnn_1_1step_CC_maskV_-1.0=0.69608665, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59791499, val_rnn_1_1step_R2_maskV_-1.0=0.31846696, val_rnn_1_1step_CC_maskV_-1.0=0.62983072, learning_rate=0.001\n", + "Epoch 65/155 - loss=rnn_1_1step_loss=0.47209358, rnn_1_1step_R2_maskV_-1.0=0.51433039, rnn_1_1step_CC_maskV_-1.0=0.72468555, rnn_1_1step_MSE_maskV_-1.0=0.47209361, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56618214, val_rnn_1_1step_R2_maskV_-1.0=0.35444483, val_rnn_1_1step_CC_maskV_-1.0=0.65644562, learning_rate=0.001\n", + "Epoch 81/155 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.45377254, rnn_1_1step_R2_maskV_-1.0=0.53312945, rnn_1_1step_CC_maskV_-1.0=0.7371521, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55340213, val_rnn_1_1step_R2_maskV_-1.0=0.36685783, val_rnn_1_1step_CC_maskV_-1.0=0.66609603, learning_rate=0.001\n", + "Epoch 97/155 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44529763, rnn_1_1step_R2_maskV_-1.0=0.54166931, rnn_1_1step_CC_maskV_-1.0=0.74288976, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54758269, val_rnn_1_1step_R2_maskV_-1.0=0.37274653, val_rnn_1_1step_CC_maskV_-1.0=0.67094636, learning_rate=0.001\n", + "Epoch 113/155 - loss=rnn_1_1step_loss=0.43788719, rnn_1_1step_R2_maskV_-1.0=0.54903096, rnn_1_1step_CC_maskV_-1.0=0.74789071, rnn_1_1step_MSE_maskV_-1.0=0.43788722, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54278928, val_rnn_1_1step_R2_maskV_-1.0=0.37781075, val_rnn_1_1step_CC_maskV_-1.0=0.67537963, learning_rate=0.001\n", + "Epoch 129/155 - loss=rnn_1_1step_loss=0.43265387, rnn_1_1step_R2_maskV_-1.0=0.55416095, rnn_1_1step_CC_maskV_-1.0=0.75139427, rnn_1_1step_MSE_maskV_-1.0=0.4326539, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54065728, val_rnn_1_1step_R2_maskV_-1.0=0.38008553, val_rnn_1_1step_CC_maskV_-1.0=0.67793769, learning_rate=0.001\n", + "Epoch 145/155 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42944407, rnn_1_1step_R2_maskV_-1.0=0.55728376, rnn_1_1step_CC_maskV_-1.0=0.75353926, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54043323, val_rnn_1_1step_R2_maskV_-1.0=0.38030344, val_rnn_1_1step_CC_maskV_-1.0=0.67894697, learning_rate=0.001\n", + "Epoch 155/155 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42811513, rnn_1_1step_R2_maskV_-1.0=0.5585767, rnn_1_1step_CC_maskV_-1.0=0.75442964, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54070377, val_rnn_1_1step_R2_maskV_-1.0=0.37998945, val_rnn_1_1step_CC_maskV_-1.0=0.67915708, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:44:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 17.27s\n", + "\u001b[32m2025-05-30 10:44:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.52254254)\n", + "\u001b[32m2025-05-30 10:44:13\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.363, R2_maskV_-1.0=0.637, CC_maskV_-1.0=0.798\n", + "\u001b[32m2025-05-30 10:44:13\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.502, R2_maskV_-1.0=0.437, CC_maskV_-1.0=0.714\n", + "\u001b[32m2025-05-30 10:44:13\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 10:44:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:44:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 117 (stopped at 132 epochs).\n", + "\u001b[32m2025-05-30 10:44:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/133 - loss=38.956707, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0041889013, MSE_maskV_-1.0=38.84697, val_loss=4.3708005, val_CC_maskV_-1.0=0.016427672, val_MSE_maskV_-1.0=4.352438, learning_rate=0.001\n", + "Epoch 15/133 - loss=1.0429444, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.2080535, MSE_maskV_-1.0=1.0432832, val_loss=1.048425, val_CC_maskV_-1.0=0.20010357, val_MSE_maskV_-1.0=1.0465168, learning_rate=0.001\n", + "Epoch 29/133 - loss=0.90038276, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.33930162, MSE_maskV_-1.0=0.89962691, val_loss=0.90157998, val_CC_maskV_-1.0=0.33615279, val_MSE_maskV_-1.0=0.89985782, learning_rate=0.001\n", + "Epoch 43/133 - loss=0.81116593, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43747419, MSE_maskV_-1.0=0.81121486, val_loss=0.83308822, val_CC_maskV_-1.0=0.41359392, val_MSE_maskV_-1.0=0.83246678, learning_rate=0.001\n", + "Epoch 57/133 - loss=0.75995475, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48939559, MSE_maskV_-1.0=0.76032078, val_loss=0.78518277, val_CC_maskV_-1.0=0.46355233, val_MSE_maskV_-1.0=0.78456956, learning_rate=0.001\n", + "Epoch 71/133 - loss=0.73730844, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51127952, MSE_maskV_-1.0=0.73799407, val_loss=0.77436459, val_CC_maskV_-1.0=0.47701457, val_MSE_maskV_-1.0=0.77423853, learning_rate=0.001\n", + "Epoch 85/133 - loss=0.72664082, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52136898, MSE_maskV_-1.0=0.72677773, val_loss=0.74177688, val_CC_maskV_-1.0=0.50159615, val_MSE_maskV_-1.0=0.7424531, learning_rate=0.001\n", + "Epoch 99/133 - loss=0.72101808, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52667671, MSE_maskV_-1.0=0.72071654, val_loss=0.74263364, val_CC_maskV_-1.0=0.50296426, val_MSE_maskV_-1.0=0.74333185, learning_rate=0.001\n", + "Epoch 113/133 - loss=0.71302491, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53368002, MSE_maskV_-1.0=0.71514189, val_loss=0.72863066, val_CC_maskV_-1.0=0.5138911, val_MSE_maskV_-1.0=0.7299735, learning_rate=0.001\n", + "Epoch 127/133 - loss=0.70738769, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53839302, MSE_maskV_-1.0=0.70873016, val_loss=0.74182379, val_CC_maskV_-1.0=0.50044972, val_MSE_maskV_-1.0=0.7419433, learning_rate=0.001\n", + "Epoch 133/133 - loss=0.7106123, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5364657, MSE_maskV_-1.0=0.70992261, val_loss=0.74199361, val_CC_maskV_-1.0=0.50357533, val_MSE_maskV_-1.0=0.74321604, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:44:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 35.47s\n", + "\u001b[32m2025-05-30 10:44:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:45:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 182 (stopped at 197 epochs).\n", + "\u001b[32m2025-05-30 10:45:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/198 - loss=38.817017, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0090947179, MSE_maskV_-1.0=38.705578, val_loss=3.6809311, val_CC_maskV_-1.0=0.022644576, val_MSE_maskV_-1.0=3.6577644, learning_rate=0.001\n", + "Epoch 21/198 - loss=0.94510573, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.2935729, MSE_maskV_-1.0=0.94485384, val_loss=0.96719331, val_CC_maskV_-1.0=0.26933375, val_MSE_maskV_-1.0=0.96597183, learning_rate=0.001\n", + "Epoch 41/198 - loss=0.82159102, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42651784, MSE_maskV_-1.0=0.82179314, val_loss=0.84604412, val_CC_maskV_-1.0=0.40403557, val_MSE_maskV_-1.0=0.8459605, learning_rate=0.001\n", + "Epoch 61/198 - loss=0.76061761, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4888376, MSE_maskV_-1.0=0.75994575, val_loss=0.76784343, val_CC_maskV_-1.0=0.47724777, val_MSE_maskV_-1.0=0.76771301, learning_rate=0.001\n", + "Epoch 81/198 - loss=0.72887069, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51892138, MSE_maskV_-1.0=0.72873974, val_loss=0.75660604, val_CC_maskV_-1.0=0.48800838, val_MSE_maskV_-1.0=0.75682658, learning_rate=0.001\n", + "Epoch 101/198 - loss=0.72013021, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52802938, MSE_maskV_-1.0=0.71993542, val_loss=0.74650878, val_CC_maskV_-1.0=0.4972671, val_MSE_maskV_-1.0=0.74706304, learning_rate=0.001\n", + "Epoch 121/198 - loss=0.71273464, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53373647, MSE_maskV_-1.0=0.7129153, val_loss=0.74185568, val_CC_maskV_-1.0=0.50404936, val_MSE_maskV_-1.0=0.74119753, learning_rate=0.001\n", + "Epoch 141/198 - loss=0.71245503, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53477776, MSE_maskV_-1.0=0.71601701, val_loss=0.732494, val_CC_maskV_-1.0=0.50991684, val_MSE_maskV_-1.0=0.7324968, learning_rate=0.001\n", + "Epoch 161/198 - loss=0.70514035, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54138225, MSE_maskV_-1.0=0.70527822, val_loss=0.7460531, val_CC_maskV_-1.0=0.49791062, val_MSE_maskV_-1.0=0.74633491, learning_rate=0.001\n", + "Epoch 181/198 - loss=0.70188999, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54347306, MSE_maskV_-1.0=0.70181167, val_loss=0.72797716, val_CC_maskV_-1.0=0.51604062, val_MSE_maskV_-1.0=0.72804075, learning_rate=0.001\n", + "Epoch 198/198 - loss=0.69772917, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54691672, MSE_maskV_-1.0=0.69804358, val_loss=0.72357827, val_CC_maskV_-1.0=0.51838213, val_MSE_maskV_-1.0=0.72366506, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:45:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 51.57s\n", + "\u001b[32m2025-05-30 10:45:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.71883714)\n", + "\u001b[32m2025-05-30 10:45:40\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 806us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:45:41\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.687, R2_maskV_-1.0=0.314, CC_maskV_-1.0=0.56\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 856us/step\n", + "51/51 [==============================] - 0s 811us/step\n", + "84/84 [==============================] - 0s 754us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:45:42\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_Cy1HL64U_ErSV16\" (5/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_Cy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 10:45:42\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_uAK1HL64U_ErSV16\" (6/16)\n", + "\u001b[32m2025-05-30 10:45:42\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAK1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 10:45:42\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 10:45:42\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 10:45:42\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 10:45:42\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 10:45:42\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 10:45:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:45:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 56 (stopped at 71 epochs).\n", + "\u001b[32m2025-05-30 10:45:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/72 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.99863249, rnn_1step_R2_maskV_-1.0=-0.021507826, rnn_1step_CC_maskV_-1.0=0.10051994, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96474713, val_rnn_1step_R2_maskV_-1.0=-0.087592304, val_rnn_1step_CC_maskV_-1.0=0.25415573, learning_rate=0.001\n", + "Epoch 9/72 - loss=rnn_1step_loss=0.90745813, rnn_1step_R2_maskV_-1.0=0.07251665, rnn_1step_CC_maskV_-1.0=0.40388736, rnn_1step_MSE_maskV_-1.0=0.90745819, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.86462229, val_rnn_1step_R2_maskV_-1.0=0.017555177, val_rnn_1step_CC_maskV_-1.0=0.39712444, learning_rate=0.001\n", + "Epoch 17/72 - loss=rnn_1step_loss=0.64927298, rnn_1step_R2_maskV_-1.0=0.32960504, rnn_1step_CC_maskV_-1.0=0.5952388, rnn_1step_MSE_maskV_-1.0=0.64927292, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.68186504, val_rnn_1step_R2_maskV_-1.0=0.22041079, val_rnn_1step_CC_maskV_-1.0=0.54064614, learning_rate=0.001\n", + "Epoch 25/72 - loss=rnn_1step_loss=0.51347274, rnn_1step_R2_maskV_-1.0=0.46589756, rnn_1step_CC_maskV_-1.0=0.6972599, rnn_1step_MSE_maskV_-1.0=0.5134728, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6088438, val_rnn_1step_R2_maskV_-1.0=0.30293953, val_rnn_1step_CC_maskV_-1.0=0.61499619, learning_rate=0.001\n", + "Epoch 33/72 - loss=rnn_1step_loss=0.42474499, rnn_1step_R2_maskV_-1.0=0.55781418, rnn_1step_CC_maskV_-1.0=0.75797272, rnn_1step_MSE_maskV_-1.0=0.42474502, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56193101, val_rnn_1step_R2_maskV_-1.0=0.358473, val_rnn_1step_CC_maskV_-1.0=0.64961076, learning_rate=0.001\n", + "Epoch 41/72 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37577465, rnn_1step_R2_maskV_-1.0=0.60952353, rnn_1step_CC_maskV_-1.0=0.78927076, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55492032, val_rnn_1step_R2_maskV_-1.0=0.36561844, val_rnn_1step_CC_maskV_-1.0=0.65731972, learning_rate=0.001\n", + "Epoch 49/72 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34817863, rnn_1step_R2_maskV_-1.0=0.63829327, rnn_1step_CC_maskV_-1.0=0.80655622, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54943341, val_rnn_1step_R2_maskV_-1.0=0.37139434, val_rnn_1step_CC_maskV_-1.0=0.66394204, learning_rate=0.001\n", + "Epoch 57/72 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32762811, rnn_1step_R2_maskV_-1.0=0.65978038, rnn_1step_CC_maskV_-1.0=0.81866467, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55873543, val_rnn_1step_R2_maskV_-1.0=0.35995877, val_rnn_1step_CC_maskV_-1.0=0.66174579, learning_rate=0.001\n", + "Epoch 65/72 - loss=rnn_1step_loss=0.30841288, rnn_1step_R2_maskV_-1.0=0.67967999, rnn_1step_CC_maskV_-1.0=0.83081466, rnn_1step_MSE_maskV_-1.0=0.30841285, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54483652, val_rnn_1step_R2_maskV_-1.0=0.37679863, val_rnn_1step_CC_maskV_-1.0=0.67095816, learning_rate=0.001\n", + "Epoch 72/72 - loss=rnn_1step_loss=0.2915872, rnn_1step_R2_maskV_-1.0=0.69734675, rnn_1step_CC_maskV_-1.0=0.84089446, rnn_1step_MSE_maskV_-1.0=0.29158723, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55212641, val_rnn_1step_R2_maskV_-1.0=0.36841154, val_rnn_1step_CC_maskV_-1.0=0.66998333, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:45:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.11s\n", + "\u001b[32m2025-05-30 10:45:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:46:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 83 (stopped at 98 epochs).\n", + "\u001b[32m2025-05-30 10:46:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/99 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.99934101, rnn_1_1step_R2_maskV_-1.0=-0.022248317, rnn_1_1step_CC_maskV_-1.0=0.026370965, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96369463, val_rnn_1_1step_R2_maskV_-1.0=-0.086251795, val_rnn_1_1step_CC_maskV_-1.0=0.28845763, learning_rate=0.001\n", + "Epoch 11/99 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.84826821, rnn_1_1step_R2_maskV_-1.0=0.13057759, rnn_1_1step_CC_maskV_-1.0=0.39855227, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.79580659, val_rnn_1_1step_R2_maskV_-1.0=0.09314315, val_rnn_1_1step_CC_maskV_-1.0=0.41617557, learning_rate=0.001\n", + "Epoch 21/99 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.63767558, rnn_1_1step_R2_maskV_-1.0=0.34007949, rnn_1_1step_CC_maskV_-1.0=0.60174179, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.68971401, val_rnn_1_1step_R2_maskV_-1.0=0.21245627, val_rnn_1_1step_CC_maskV_-1.0=0.53873414, learning_rate=0.001\n", + "Epoch 31/99 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.52199125, rnn_1_1step_R2_maskV_-1.0=0.45777154, rnn_1_1step_CC_maskV_-1.0=0.68962502, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63039392, val_rnn_1_1step_R2_maskV_-1.0=0.2790187, val_rnn_1_1step_CC_maskV_-1.0=0.59521997, learning_rate=0.001\n", + "Epoch 41/99 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42899051, rnn_1_1step_R2_maskV_-1.0=0.55482644, rnn_1_1step_CC_maskV_-1.0=0.75422299, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58352309, val_rnn_1_1step_R2_maskV_-1.0=0.33173728, val_rnn_1_1step_CC_maskV_-1.0=0.63464123, learning_rate=0.001\n", + "Epoch 51/99 - loss=rnn_1_1step_loss=0.36263213, rnn_1_1step_R2_maskV_-1.0=0.62463862, rnn_1_1step_CC_maskV_-1.0=0.79701006, rnn_1_1step_MSE_maskV_-1.0=0.3626321, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55823666, val_rnn_1_1step_R2_maskV_-1.0=0.35829777, val_rnn_1_1step_CC_maskV_-1.0=0.65994841, learning_rate=0.001\n", + "Epoch 61/99 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32910046, rnn_1_1step_R2_maskV_-1.0=0.65958536, rnn_1_1step_CC_maskV_-1.0=0.81809282, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57118076, val_rnn_1_1step_R2_maskV_-1.0=0.34207761, val_rnn_1_1step_CC_maskV_-1.0=0.65914363, learning_rate=0.001\n", + "Epoch 71/99 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.29675862, rnn_1_1step_R2_maskV_-1.0=0.69346356, rnn_1_1step_CC_maskV_-1.0=0.83757472, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57256669, val_rnn_1_1step_R2_maskV_-1.0=0.34136897, val_rnn_1_1step_CC_maskV_-1.0=0.65998679, learning_rate=0.001\n", + "Epoch 81/99 - loss=rnn_1_1step_loss=0.27792606, rnn_1_1step_R2_maskV_-1.0=0.71298647, rnn_1_1step_CC_maskV_-1.0=0.84875345, rnn_1_1step_MSE_maskV_-1.0=0.27792603, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53507614, val_rnn_1_1step_R2_maskV_-1.0=0.38645542, val_rnn_1_1step_CC_maskV_-1.0=0.68115723, learning_rate=0.001\n", + "Epoch 91/99 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.26164755, rnn_1_1step_R2_maskV_-1.0=0.72985476, rnn_1_1step_CC_maskV_-1.0=0.85879767, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5357545, val_rnn_1_1step_R2_maskV_-1.0=0.38529232, val_rnn_1_1step_CC_maskV_-1.0=0.68320292, learning_rate=0.001\n", + "Epoch 99/99 - loss=rnn_1_1step_loss=0.24467987, rnn_1_1step_R2_maskV_-1.0=0.74754071, rnn_1_1step_CC_maskV_-1.0=0.86809123, rnn_1_1step_MSE_maskV_-1.0=0.24467985, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53386062, val_rnn_1_1step_R2_maskV_-1.0=0.38726413, val_rnn_1_1step_CC_maskV_-1.0=0.68817341, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:46:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.88s\n", + "\u001b[32m2025-05-30 10:46:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.51372343)\n", + "\u001b[32m2025-05-30 10:46:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.254, R2_maskV_-1.0=0.746, CC_maskV_-1.0=0.865\n", + "\u001b[32m2025-05-30 10:46:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.489, R2_maskV_-1.0=0.454, CC_maskV_-1.0=0.716\n", + "\u001b[32m2025-05-30 10:46:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 10:46:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:47:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 314 (stopped at 329 epochs).\n", + "\u001b[32m2025-05-30 10:47:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/330 - loss=1.3479116, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.075243481, MSE_maskV_-1.0=1.3490677, val_loss=1.0070616, val_CC_maskV_-1.0=0.15131518, val_MSE_maskV_-1.0=1.0041467, learning_rate=0.001\n", + "Epoch 34/330 - loss=0.90312374, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.31414163, MSE_maskV_-1.0=0.90504366, val_loss=0.90965813, val_CC_maskV_-1.0=0.31730962, val_MSE_maskV_-1.0=0.90734363, learning_rate=0.001\n", + "Epoch 67/330 - loss=0.88572717, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34166858, MSE_maskV_-1.0=0.88519514, val_loss=0.89325154, val_CC_maskV_-1.0=0.34025946, val_MSE_maskV_-1.0=0.89104724, learning_rate=0.001\n", + "Epoch 100/330 - loss=0.87515622, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35584754, MSE_maskV_-1.0=0.87444592, val_loss=0.88138771, val_CC_maskV_-1.0=0.35631058, val_MSE_maskV_-1.0=0.87929589, learning_rate=0.001\n", + "Epoch 133/330 - loss=0.86802506, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.365428, MSE_maskV_-1.0=0.86718005, val_loss=0.87533706, val_CC_maskV_-1.0=0.36413237, val_MSE_maskV_-1.0=0.87300336, learning_rate=0.001\n", + "Epoch 166/330 - loss=0.86296469, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37183607, MSE_maskV_-1.0=0.86347514, val_loss=0.86909533, val_CC_maskV_-1.0=0.37117282, val_MSE_maskV_-1.0=0.86669832, learning_rate=0.001\n", + "Epoch 199/330 - loss=0.85917592, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37679136, MSE_maskV_-1.0=0.85911804, val_loss=0.86562353, val_CC_maskV_-1.0=0.37568018, val_MSE_maskV_-1.0=0.86298656, learning_rate=0.001\n", + "Epoch 232/330 - loss=0.8559112, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38061264, MSE_maskV_-1.0=0.85543132, val_loss=0.86078501, val_CC_maskV_-1.0=0.38051608, val_MSE_maskV_-1.0=0.8582896, learning_rate=0.001\n", + "Epoch 265/330 - loss=0.85355699, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38273701, MSE_maskV_-1.0=0.85391122, val_loss=0.86078548, val_CC_maskV_-1.0=0.38115701, val_MSE_maskV_-1.0=0.85815692, learning_rate=0.001\n", + "Epoch 298/330 - loss=0.85160822, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38614792, MSE_maskV_-1.0=0.85107052, val_loss=0.85574305, val_CC_maskV_-1.0=0.38540268, val_MSE_maskV_-1.0=0.85351586, learning_rate=0.001\n", + "Epoch 330/330 - loss=0.85005265, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38739434, MSE_maskV_-1.0=0.84968561, val_loss=0.85600698, val_CC_maskV_-1.0=0.38676763, val_MSE_maskV_-1.0=0.85296667, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:47:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 79.62s\n", + "\u001b[32m2025-05-30 10:47:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:48:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 314 (stopped at 329 epochs).\n", + "\u001b[32m2025-05-30 10:48:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/330 - loss=1.3929018, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.057916541, MSE_maskV_-1.0=1.3938166, val_loss=1.0167373, val_CC_maskV_-1.0=0.13771276, val_MSE_maskV_-1.0=1.0137614, learning_rate=0.001\n", + "Epoch 34/330 - loss=0.90482974, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.31116623, MSE_maskV_-1.0=0.90677184, val_loss=0.91140223, val_CC_maskV_-1.0=0.31520972, val_MSE_maskV_-1.0=0.90892357, learning_rate=0.001\n", + "Epoch 67/330 - loss=0.88662302, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34029928, MSE_maskV_-1.0=0.88607597, val_loss=0.89436126, val_CC_maskV_-1.0=0.33910257, val_MSE_maskV_-1.0=0.8920399, learning_rate=0.001\n", + "Epoch 100/330 - loss=0.8756969, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3550556, MSE_maskV_-1.0=0.87497687, val_loss=0.88214564, val_CC_maskV_-1.0=0.35551217, val_MSE_maskV_-1.0=0.87997645, learning_rate=0.001\n", + "Epoch 133/330 - loss=0.86838168, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36494797, MSE_maskV_-1.0=0.8675366, val_loss=0.87597007, val_CC_maskV_-1.0=0.36341339, val_MSE_maskV_-1.0=0.87356383, learning_rate=0.001\n", + "Epoch 166/330 - loss=0.86320746, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37153572, MSE_maskV_-1.0=0.86370713, val_loss=0.86949211, val_CC_maskV_-1.0=0.37071621, val_MSE_maskV_-1.0=0.8670308, learning_rate=0.001\n", + "Epoch 199/330 - loss=0.85934371, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37659103, MSE_maskV_-1.0=0.85928869, val_loss=0.86593193, val_CC_maskV_-1.0=0.3753019, val_MSE_maskV_-1.0=0.86326551, learning_rate=0.001\n", + "Epoch 232/330 - loss=0.85603327, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38045514, MSE_maskV_-1.0=0.85555607, val_loss=0.8610636, val_CC_maskV_-1.0=0.38017616, val_MSE_maskV_-1.0=0.85853755, learning_rate=0.001\n", + "Epoch 265/330 - loss=0.85363603, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3826552, MSE_maskV_-1.0=0.85397428, val_loss=0.86097592, val_CC_maskV_-1.0=0.38090557, val_MSE_maskV_-1.0=0.85832191, learning_rate=0.001\n", + "Epoch 298/330 - loss=0.85166425, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38607946, MSE_maskV_-1.0=0.8511219, val_loss=0.85590768, val_CC_maskV_-1.0=0.38515723, val_MSE_maskV_-1.0=0.85366744, learning_rate=0.001\n", + "Epoch 330/330 - loss=0.85009623, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38731927, MSE_maskV_-1.0=0.84973037, val_loss=0.85610485, val_CC_maskV_-1.0=0.38661543, val_MSE_maskV_-1.0=0.85305578, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:48:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 79.46s\n", + "\u001b[32m2025-05-30 10:48:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.85531658)\n", + "\u001b[32m2025-05-30 10:48:46\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 1ms/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:48:47\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.85, R2_maskV_-1.0=0.151, CC_maskV_-1.0=0.389\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 781us/step\n", + "51/51 [==============================] - 0s 783us/step\n", + "84/84 [==============================] - 0s 701us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:48:48\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_uAK1HL64U_ErSV16\" (6/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_uAK1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 10:48:48\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_ACz1HL64U_ErSV16\" (7/16)\n", + "\u001b[32m2025-05-30 10:48:48\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 10:48:48\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 10:48:48\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 10:48:48\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 10:48:48\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 10:48:48\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 10:48:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:49:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 134 (stopped at 149 epochs).\n", + "\u001b[32m2025-05-30 10:49:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/150 - loss=rnn_1step_loss=0.99913073, rnn_1step_R2_maskV_-1.0=-0.022020821, rnn_1step_CC_maskV_-1.0=0.046867222, rnn_1step_MSE_maskV_-1.0=0.99913079, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96459293, val_rnn_1step_R2_maskV_-1.0=-0.087318212, val_rnn_1step_CC_maskV_-1.0=0.23240201, learning_rate=0.001\n", + "Epoch 16/150 - loss=rnn_1step_loss=0.7132327, rnn_1step_R2_maskV_-1.0=0.26255363, rnn_1step_CC_maskV_-1.0=0.53632832, rnn_1step_MSE_maskV_-1.0=0.71323264, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.73843545, val_rnn_1step_R2_maskV_-1.0=0.15610185, val_rnn_1step_CC_maskV_-1.0=0.49650398, learning_rate=0.001\n", + "Epoch 31/150 - loss=rnn_1step_loss=0.55908102, rnn_1step_R2_maskV_-1.0=0.42159483, rnn_1step_CC_maskV_-1.0=0.66353643, rnn_1step_MSE_maskV_-1.0=0.55908108, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.65812367, val_rnn_1step_R2_maskV_-1.0=0.24965334, val_rnn_1step_CC_maskV_-1.0=0.57222664, learning_rate=0.001\n", + "Epoch 46/150 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.49387431, rnn_1step_R2_maskV_-1.0=0.48998868, rnn_1step_CC_maskV_-1.0=0.71041381, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61332226, val_rnn_1step_R2_maskV_-1.0=0.30015022, val_rnn_1step_CC_maskV_-1.0=0.60835528, learning_rate=0.001\n", + "Epoch 61/150 - loss=rnn_1step_loss=0.46226141, rnn_1step_R2_maskV_-1.0=0.52276158, rnn_1step_CC_maskV_-1.0=0.73236489, rnn_1step_MSE_maskV_-1.0=0.46226144, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58103055, val_rnn_1step_R2_maskV_-1.0=0.33451444, val_rnn_1step_CC_maskV_-1.0=0.63171339, learning_rate=0.001\n", + "Epoch 76/150 - loss=rnn_1step_loss=0.43267271, rnn_1step_R2_maskV_-1.0=0.55331463, rnn_1step_CC_maskV_-1.0=0.75189704, rnn_1step_MSE_maskV_-1.0=0.43267268, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56821513, val_rnn_1step_R2_maskV_-1.0=0.34724453, val_rnn_1step_CC_maskV_-1.0=0.64635372, learning_rate=0.001\n", + "Epoch 91/150 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40895772, rnn_1step_R2_maskV_-1.0=0.57752752, rnn_1step_CC_maskV_-1.0=0.76714611, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55691051, val_rnn_1step_R2_maskV_-1.0=0.35881329, val_rnn_1step_CC_maskV_-1.0=0.66165662, learning_rate=0.001\n", + "Epoch 106/150 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38975778, rnn_1step_R2_maskV_-1.0=0.59733808, rnn_1step_CC_maskV_-1.0=0.77936268, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53717738, val_rnn_1step_R2_maskV_-1.0=0.38146055, val_rnn_1step_CC_maskV_-1.0=0.67835015, learning_rate=0.001\n", + "Epoch 121/150 - loss=rnn_1step_loss=0.37522373, rnn_1step_R2_maskV_-1.0=0.61245257, rnn_1step_CC_maskV_-1.0=0.78852397, rnn_1step_MSE_maskV_-1.0=0.37522367, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55562323, val_rnn_1step_R2_maskV_-1.0=0.35888195, val_rnn_1step_CC_maskV_-1.0=0.67417592, learning_rate=0.001\n", + "Epoch 136/150 - loss=rnn_1step_loss=0.36912808, rnn_1step_R2_maskV_-1.0=0.61881912, rnn_1step_CC_maskV_-1.0=0.79531491, rnn_1step_MSE_maskV_-1.0=0.36912805, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47352362, val_rnn_1step_R2_maskV_-1.0=0.45731294, val_rnn_1step_CC_maskV_-1.0=0.71225619, learning_rate=0.001\n", + "Epoch 150/150 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35510159, rnn_1step_R2_maskV_-1.0=0.63416052, rnn_1step_CC_maskV_-1.0=0.80319685, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51791519, val_rnn_1step_R2_maskV_-1.0=0.40349925, val_rnn_1step_CC_maskV_-1.0=0.69847947, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:49:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 17.96s\n", + "\u001b[32m2025-05-30 10:49:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:49:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 124 (stopped at 139 epochs).\n", + "\u001b[32m2025-05-30 10:49:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/140 - loss=rnn_1_1step_loss=0.99896616, rnn_1_1step_R2_maskV_-1.0=-0.021868844, rnn_1_1step_CC_maskV_-1.0=0.064203814, rnn_1_1step_MSE_maskV_-1.0=0.9989661, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96455574, val_rnn_1_1step_R2_maskV_-1.0=-0.087374866, val_rnn_1_1step_CC_maskV_-1.0=0.18933383, learning_rate=0.001\n", + "Epoch 15/140 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.72485119, rnn_1_1step_R2_maskV_-1.0=0.24961615, rnn_1_1step_CC_maskV_-1.0=0.52539349, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.74251527, val_rnn_1_1step_R2_maskV_-1.0=0.14965694, val_rnn_1_1step_CC_maskV_-1.0=0.48534891, learning_rate=0.001\n", + "Epoch 29/140 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.56082982, rnn_1_1step_R2_maskV_-1.0=0.41922683, rnn_1_1step_CC_maskV_-1.0=0.66208911, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62349433, val_rnn_1_1step_R2_maskV_-1.0=0.28752843, val_rnn_1_1step_CC_maskV_-1.0=0.59506732, learning_rate=0.001\n", + "Epoch 43/140 - loss=rnn_1_1step_loss=0.50603479, rnn_1_1step_R2_maskV_-1.0=0.47670668, rnn_1_1step_CC_maskV_-1.0=0.70206028, rnn_1_1step_MSE_maskV_-1.0=0.50603473, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59858733, val_rnn_1_1step_R2_maskV_-1.0=0.31596744, val_rnn_1_1step_CC_maskV_-1.0=0.62017196, learning_rate=0.001\n", + "Epoch 57/140 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.47128081, rnn_1_1step_R2_maskV_-1.0=0.51345855, rnn_1_1step_CC_maskV_-1.0=0.72668386, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58508635, val_rnn_1_1step_R2_maskV_-1.0=0.33100373, val_rnn_1_1step_CC_maskV_-1.0=0.6321094, learning_rate=0.001\n", + "Epoch 71/140 - loss=rnn_1_1step_loss=0.44161698, rnn_1_1step_R2_maskV_-1.0=0.54387403, rnn_1_1step_CC_maskV_-1.0=0.74681437, rnn_1_1step_MSE_maskV_-1.0=0.44161701, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57320517, val_rnn_1_1step_R2_maskV_-1.0=0.34234288, val_rnn_1_1step_CC_maskV_-1.0=0.64603931, learning_rate=0.001\n", + "Epoch 85/140 - loss=rnn_1_1step_loss=0.41237107, rnn_1_1step_R2_maskV_-1.0=0.57364619, rnn_1_1step_CC_maskV_-1.0=0.76626951, rnn_1_1step_MSE_maskV_-1.0=0.4123711, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54596502, val_rnn_1_1step_R2_maskV_-1.0=0.3735939, val_rnn_1_1step_CC_maskV_-1.0=0.6629979, learning_rate=0.001\n", + "Epoch 99/140 - loss=rnn_1_1step_loss=0.39594218, rnn_1_1step_R2_maskV_-1.0=0.5904727, rnn_1_1step_CC_maskV_-1.0=0.7755934, rnn_1_1step_MSE_maskV_-1.0=0.39594215, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55058265, val_rnn_1_1step_R2_maskV_-1.0=0.3664206, val_rnn_1_1step_CC_maskV_-1.0=0.6727466, learning_rate=0.001\n", + "Epoch 113/140 - loss=rnn_1_1step_loss=0.37834153, rnn_1_1step_R2_maskV_-1.0=0.60806608, rnn_1_1step_CC_maskV_-1.0=0.788921, rnn_1_1step_MSE_maskV_-1.0=0.3783415, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51169819, val_rnn_1_1step_R2_maskV_-1.0=0.41374111, val_rnn_1_1step_CC_maskV_-1.0=0.69313365, learning_rate=0.001\n", + "Epoch 127/140 - loss=rnn_1_1step_loss=0.36126065, rnn_1_1step_R2_maskV_-1.0=0.6253475, rnn_1_1step_CC_maskV_-1.0=0.79903972, rnn_1_1step_MSE_maskV_-1.0=0.36126062, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51069206, val_rnn_1_1step_R2_maskV_-1.0=0.41502273, val_rnn_1_1step_CC_maskV_-1.0=0.696648, learning_rate=0.001\n", + "Epoch 140/140 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.3410404, rnn_1_1step_R2_maskV_-1.0=0.64663064, rnn_1_1step_CC_maskV_-1.0=0.81164283, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51200801, val_rnn_1_1step_R2_maskV_-1.0=0.41265023, val_rnn_1_1step_CC_maskV_-1.0=0.70125169, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:49:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 17.23s\n", + "\u001b[32m2025-05-30 10:49:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.47195134)\n", + "\u001b[32m2025-05-30 10:49:25\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.345, R2_maskV_-1.0=0.654, CC_maskV_-1.0=0.811\n", + "\u001b[32m2025-05-30 10:49:25\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.469, R2_maskV_-1.0=0.475, CC_maskV_-1.0=0.724\n", + "\u001b[32m2025-05-30 10:49:25\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 10:49:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:49:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 90 (stopped at 105 epochs).\n", + "\u001b[32m2025-05-30 10:49:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/106 - loss=2.1645644, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.061180424, MSE_maskV_-1.0=2.1644571, val_loss=1.2149023, val_CC_maskV_-1.0=0.13798459, val_MSE_maskV_-1.0=1.2077806, learning_rate=0.001\n", + "Epoch 12/106 - loss=0.77030355, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47771069, MSE_maskV_-1.0=0.76998645, val_loss=0.76572478, val_CC_maskV_-1.0=0.4843663, val_MSE_maskV_-1.0=0.76413584, learning_rate=0.001\n", + "Epoch 23/106 - loss=0.73649025, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51296651, MSE_maskV_-1.0=0.7362929, val_loss=0.73338723, val_CC_maskV_-1.0=0.51638126, val_MSE_maskV_-1.0=0.7320413, learning_rate=0.001\n", + "Epoch 34/106 - loss=0.72156185, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52595925, MSE_maskV_-1.0=0.72316027, val_loss=0.71834409, val_CC_maskV_-1.0=0.5309062, val_MSE_maskV_-1.0=0.71683788, learning_rate=0.001\n", + "Epoch 45/106 - loss=0.71375865, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53315175, MSE_maskV_-1.0=0.71343255, val_loss=0.71373391, val_CC_maskV_-1.0=0.53416276, val_MSE_maskV_-1.0=0.71256053, learning_rate=0.001\n", + "Epoch 56/106 - loss=0.70911735, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53786045, MSE_maskV_-1.0=0.70906001, val_loss=0.70986354, val_CC_maskV_-1.0=0.53785592, val_MSE_maskV_-1.0=0.70848203, learning_rate=0.001\n", + "Epoch 67/106 - loss=0.7061947, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53972334, MSE_maskV_-1.0=0.70582783, val_loss=0.70767802, val_CC_maskV_-1.0=0.53936338, val_MSE_maskV_-1.0=0.706725, learning_rate=0.001\n", + "Epoch 78/106 - loss=0.70456582, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54070622, MSE_maskV_-1.0=0.70428741, val_loss=0.70643049, val_CC_maskV_-1.0=0.54080158, val_MSE_maskV_-1.0=0.70538527, learning_rate=0.001\n", + "Epoch 89/106 - loss=0.70314801, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54271841, MSE_maskV_-1.0=0.7040416, val_loss=0.70354503, val_CC_maskV_-1.0=0.54337239, val_MSE_maskV_-1.0=0.70243341, learning_rate=0.001\n", + "Epoch 100/106 - loss=0.70231432, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54328942, MSE_maskV_-1.0=0.7019425, val_loss=0.70280093, val_CC_maskV_-1.0=0.54384094, val_MSE_maskV_-1.0=0.70185488, learning_rate=0.001\n", + "Epoch 106/106 - loss=0.70230353, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54345894, MSE_maskV_-1.0=0.70168799, val_loss=0.70405638, val_CC_maskV_-1.0=0.5430783, val_MSE_maskV_-1.0=0.70277029, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:49:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 25.62s\n", + "\u001b[32m2025-05-30 10:49:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:50:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 105 (stopped at 120 epochs).\n", + "\u001b[32m2025-05-30 10:50:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/121 - loss=2.1437204, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.035596386, MSE_maskV_-1.0=2.143363, val_loss=1.2128466, val_CC_maskV_-1.0=0.10562511, val_MSE_maskV_-1.0=1.2078768, learning_rate=0.001\n", + "Epoch 14/121 - loss=0.77145034, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47642589, MSE_maskV_-1.0=0.77324891, val_loss=0.76658893, val_CC_maskV_-1.0=0.48241147, val_MSE_maskV_-1.0=0.76488823, learning_rate=0.001\n", + "Epoch 27/121 - loss=0.73428595, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51475555, MSE_maskV_-1.0=0.73497313, val_loss=0.73132992, val_CC_maskV_-1.0=0.51804537, val_MSE_maskV_-1.0=0.72986311, learning_rate=0.001\n", + "Epoch 40/121 - loss=0.71894938, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52901059, MSE_maskV_-1.0=0.71880239, val_loss=0.71824557, val_CC_maskV_-1.0=0.53045911, val_MSE_maskV_-1.0=0.71688223, learning_rate=0.001\n", + "Epoch 53/121 - loss=0.71151197, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53506118, MSE_maskV_-1.0=0.71082783, val_loss=0.71159989, val_CC_maskV_-1.0=0.53629345, val_MSE_maskV_-1.0=0.71049672, learning_rate=0.001\n", + "Epoch 66/121 - loss=0.70720005, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53893065, MSE_maskV_-1.0=0.70696664, val_loss=0.70606369, val_CC_maskV_-1.0=0.5419783, val_MSE_maskV_-1.0=0.70457667, learning_rate=0.001\n", + "Epoch 79/121 - loss=0.70454752, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54180092, MSE_maskV_-1.0=0.70441037, val_loss=0.70529979, val_CC_maskV_-1.0=0.54195207, val_MSE_maskV_-1.0=0.70422447, learning_rate=0.001\n", + "Epoch 92/121 - loss=0.70328766, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54241878, MSE_maskV_-1.0=0.70240766, val_loss=0.70500237, val_CC_maskV_-1.0=0.54210216, val_MSE_maskV_-1.0=0.70369446, learning_rate=0.001\n", + "Epoch 105/121 - loss=0.70241857, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54328954, MSE_maskV_-1.0=0.70195007, val_loss=0.702434, val_CC_maskV_-1.0=0.54509383, val_MSE_maskV_-1.0=0.70036846, learning_rate=0.001\n", + "Epoch 118/121 - loss=0.70177579, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54470557, MSE_maskV_-1.0=0.70162374, val_loss=0.70418084, val_CC_maskV_-1.0=0.54336721, val_MSE_maskV_-1.0=0.70257813, learning_rate=0.001\n", + "Epoch 121/121 - loss=0.70167255, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54415685, MSE_maskV_-1.0=0.70164549, val_loss=0.70411134, val_CC_maskV_-1.0=0.5439074, val_MSE_maskV_-1.0=0.70252717, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:50:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 30.07s\n", + "\u001b[32m2025-05-30 10:50:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.70198929)\n", + "\u001b[32m2025-05-30 10:50:21\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 761us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:50:21\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.702, R2_maskV_-1.0=0.3, CC_maskV_-1.0=0.546\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 693us/step\n", + "51/51 [==============================] - 0s 769us/step\n", + "84/84 [==============================] - 0s 725us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:50:22\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_ACz1HL64U_ErSV16\" (7/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_ACz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 10:50:22\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_ACy1HL64U_ErSV16\" (8/16)\n", + "\u001b[32m2025-05-30 10:50:22\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 10:50:22\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 10:50:22\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 10:50:22\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 10:50:22\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 10:50:22\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 10:50:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:50:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 115 (stopped at 130 epochs).\n", + "\u001b[32m2025-05-30 10:50:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/131 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.99467826, rnn_1step_R2_maskV_-1.0=-0.017454267, rnn_1step_CC_maskV_-1.0=0.11982137, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.95808309, val_rnn_1step_R2_maskV_-1.0=-0.08038789, val_rnn_1step_CC_maskV_-1.0=0.2052456, learning_rate=0.001\n", + "Epoch 15/131 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.74996132, rnn_1step_R2_maskV_-1.0=0.22755127, rnn_1step_CC_maskV_-1.0=0.50690114, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.74321181, val_rnn_1step_R2_maskV_-1.0=0.15149534, val_rnn_1step_CC_maskV_-1.0=0.47920996, learning_rate=0.001\n", + "Epoch 29/131 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.58086699, rnn_1step_R2_maskV_-1.0=0.39805251, rnn_1step_CC_maskV_-1.0=0.64630854, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.65563899, val_rnn_1step_R2_maskV_-1.0=0.25169176, val_rnn_1step_CC_maskV_-1.0=0.57115883, learning_rate=0.001\n", + "Epoch 43/131 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.52705604, rnn_1step_R2_maskV_-1.0=0.45462582, rnn_1step_CC_maskV_-1.0=0.68606681, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63723379, val_rnn_1step_R2_maskV_-1.0=0.27249134, val_rnn_1step_CC_maskV_-1.0=0.59422851, learning_rate=0.001\n", + "Epoch 57/131 - loss=rnn_1step_loss=0.49108791, rnn_1step_R2_maskV_-1.0=0.49207103, rnn_1step_CC_maskV_-1.0=0.71171486, rnn_1step_MSE_maskV_-1.0=0.49108794, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6268782, val_rnn_1step_R2_maskV_-1.0=0.28375959, val_rnn_1step_CC_maskV_-1.0=0.60727805, learning_rate=0.001\n", + "Epoch 71/131 - loss=rnn_1step_loss=0.44329187, rnn_1step_R2_maskV_-1.0=0.54078686, rnn_1step_CC_maskV_-1.0=0.74420804, rnn_1step_MSE_maskV_-1.0=0.44329181, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61326271, val_rnn_1step_R2_maskV_-1.0=0.29412419, val_rnn_1step_CC_maskV_-1.0=0.63055766, learning_rate=0.001\n", + "Epoch 85/131 - loss=rnn_1step_loss=0.41668406, rnn_1step_R2_maskV_-1.0=0.56839293, rnn_1step_CC_maskV_-1.0=0.76149255, rnn_1step_MSE_maskV_-1.0=0.41668412, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54901522, val_rnn_1step_R2_maskV_-1.0=0.36998487, val_rnn_1step_CC_maskV_-1.0=0.66210878, learning_rate=0.001\n", + "Epoch 99/131 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40243831, rnn_1step_R2_maskV_-1.0=0.58313894, rnn_1step_CC_maskV_-1.0=0.77065837, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55811846, val_rnn_1step_R2_maskV_-1.0=0.35874566, val_rnn_1step_CC_maskV_-1.0=0.66275072, learning_rate=0.001\n", + "Epoch 113/131 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3944076, rnn_1step_R2_maskV_-1.0=0.59099746, rnn_1step_CC_maskV_-1.0=0.7767573, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53075027, val_rnn_1step_R2_maskV_-1.0=0.39230034, val_rnn_1step_CC_maskV_-1.0=0.67092746, learning_rate=0.001\n", + "Epoch 127/131 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37414208, rnn_1step_R2_maskV_-1.0=0.61237633, rnn_1step_CC_maskV_-1.0=0.78984261, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52892804, val_rnn_1step_R2_maskV_-1.0=0.39519829, val_rnn_1step_CC_maskV_-1.0=0.67623764, learning_rate=0.001\n", + "Epoch 131/131 - loss=rnn_1step_loss=0.37241623, rnn_1step_R2_maskV_-1.0=0.61427712, rnn_1step_CC_maskV_-1.0=0.79044652, rnn_1step_MSE_maskV_-1.0=0.3724162, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.530554, val_rnn_1step_R2_maskV_-1.0=0.39331552, val_rnn_1step_CC_maskV_-1.0=0.67522913, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:50:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 16.40s\n", + "\u001b[32m2025-05-30 10:50:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:50:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 118 (stopped at 133 epochs).\n", + "\u001b[32m2025-05-30 10:50:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/134 - loss=rnn_1_1step_loss=0.99789208, rnn_1_1step_R2_maskV_-1.0=-0.020695619, rnn_1_1step_CC_maskV_-1.0=0.046744652, rnn_1_1step_MSE_maskV_-1.0=0.99789196, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.95982343, val_rnn_1_1step_R2_maskV_-1.0=-0.081774101, val_rnn_1_1step_CC_maskV_-1.0=0.17840365, learning_rate=0.001\n", + "Epoch 15/134 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.72974843, rnn_1_1step_R2_maskV_-1.0=0.24849407, rnn_1_1step_CC_maskV_-1.0=0.52259254, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.71379095, val_rnn_1_1step_R2_maskV_-1.0=0.18720303, val_rnn_1_1step_CC_maskV_-1.0=0.50348938, learning_rate=0.001\n", + "Epoch 29/134 - loss=rnn_1_1step_loss=0.58402222, rnn_1_1step_R2_maskV_-1.0=0.39782, rnn_1_1step_CC_maskV_-1.0=0.64450276, rnn_1_1step_MSE_maskV_-1.0=0.58402216, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65658045, val_rnn_1_1step_R2_maskV_-1.0=0.25127476, val_rnn_1_1step_CC_maskV_-1.0=0.57014412, learning_rate=0.001\n", + "Epoch 43/134 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.53791445, rnn_1_1step_R2_maskV_-1.0=0.44590962, rnn_1_1step_CC_maskV_-1.0=0.67824388, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64365107, val_rnn_1_1step_R2_maskV_-1.0=0.2658717, val_rnn_1_1step_CC_maskV_-1.0=0.58584106, learning_rate=0.001\n", + "Epoch 57/134 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.5093388, rnn_1_1step_R2_maskV_-1.0=0.47570205, rnn_1_1step_CC_maskV_-1.0=0.69861495, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63678628, val_rnn_1_1step_R2_maskV_-1.0=0.27183959, val_rnn_1_1step_CC_maskV_-1.0=0.59587437, learning_rate=0.001\n", + "Epoch 71/134 - loss=rnn_1_1step_loss=0.48867035, rnn_1_1step_R2_maskV_-1.0=0.49670792, rnn_1_1step_CC_maskV_-1.0=0.71303141, rnn_1_1step_MSE_maskV_-1.0=0.48867038, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62474769, val_rnn_1_1step_R2_maskV_-1.0=0.28462812, val_rnn_1_1step_CC_maskV_-1.0=0.60599065, learning_rate=0.001\n", + "Epoch 85/134 - loss=rnn_1_1step_loss=0.47406724, rnn_1_1step_R2_maskV_-1.0=0.51145923, rnn_1_1step_CC_maskV_-1.0=0.72380304, rnn_1_1step_MSE_maskV_-1.0=0.47406721, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60490566, val_rnn_1_1step_R2_maskV_-1.0=0.30677515, val_rnn_1_1step_CC_maskV_-1.0=0.62020534, learning_rate=0.001\n", + "Epoch 99/134 - loss=rnn_1_1step_loss=0.45423427, rnn_1_1step_R2_maskV_-1.0=0.53153884, rnn_1_1step_CC_maskV_-1.0=0.73727912, rnn_1_1step_MSE_maskV_-1.0=0.4542343, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58529782, val_rnn_1_1step_R2_maskV_-1.0=0.32804656, val_rnn_1_1step_CC_maskV_-1.0=0.63839722, learning_rate=0.001\n", + "Epoch 113/134 - loss=rnn_1_1step_loss=0.44335029, rnn_1_1step_R2_maskV_-1.0=0.54099488, rnn_1_1step_CC_maskV_-1.0=0.74466693, rnn_1_1step_MSE_maskV_-1.0=0.44335026, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58319694, val_rnn_1_1step_R2_maskV_-1.0=0.3283686, val_rnn_1_1step_CC_maskV_-1.0=0.64895439, learning_rate=0.001\n", + "Epoch 127/134 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41259465, rnn_1_1step_R2_maskV_-1.0=0.57342029, rnn_1_1step_CC_maskV_-1.0=0.76386118, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56359148, val_rnn_1_1step_R2_maskV_-1.0=0.35072076, val_rnn_1_1step_CC_maskV_-1.0=0.65789437, learning_rate=0.001\n", + "Epoch 134/134 - loss=rnn_1_1step_loss=0.40676913, rnn_1_1step_R2_maskV_-1.0=0.57919574, rnn_1_1step_CC_maskV_-1.0=0.76796174, rnn_1_1step_MSE_maskV_-1.0=0.4067691, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5590871, val_rnn_1_1step_R2_maskV_-1.0=0.3564755, val_rnn_1_1step_CC_maskV_-1.0=0.65972561, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:50:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 16.48s\n", + "\u001b[32m2025-05-30 10:50:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.51874685)\n", + "\u001b[32m2025-05-30 10:50:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.365, R2_maskV_-1.0=0.635, CC_maskV_-1.0=0.8\n", + "\u001b[32m2025-05-30 10:50:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.502, R2_maskV_-1.0=0.44, CC_maskV_-1.0=0.696\n", + "\u001b[32m2025-05-30 10:50:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 10:50:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:51:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 79 (stopped at 94 epochs).\n", + "\u001b[32m2025-05-30 10:51:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/95 - loss=1.0844855, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.17242236, MSE_maskV_-1.0=1.0853229, val_loss=0.91515726, val_CC_maskV_-1.0=0.29765838, val_MSE_maskV_-1.0=0.91262001, learning_rate=0.001\n", + "Epoch 11/95 - loss=0.70717245, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53822851, MSE_maskV_-1.0=0.70749235, val_loss=0.71716303, val_CC_maskV_-1.0=0.53111029, val_MSE_maskV_-1.0=0.713045, learning_rate=0.001\n", + "Epoch 21/95 - loss=0.67160577, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57137865, MSE_maskV_-1.0=0.6715138, val_loss=0.69328713, val_CC_maskV_-1.0=0.55454403, val_MSE_maskV_-1.0=0.68843353, learning_rate=0.001\n", + "Epoch 31/95 - loss=0.65650553, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58350009, MSE_maskV_-1.0=0.6567207, val_loss=0.68228537, val_CC_maskV_-1.0=0.56464845, val_MSE_maskV_-1.0=0.67732072, learning_rate=0.001\n", + "Epoch 41/95 - loss=0.64789194, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59048843, MSE_maskV_-1.0=0.64789397, val_loss=0.67877901, val_CC_maskV_-1.0=0.56794959, val_MSE_maskV_-1.0=0.67367142, learning_rate=0.001\n", + "Epoch 51/95 - loss=0.64207888, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59527761, MSE_maskV_-1.0=0.64172643, val_loss=0.67571741, val_CC_maskV_-1.0=0.56984913, val_MSE_maskV_-1.0=0.67087704, learning_rate=0.001\n", + "Epoch 61/95 - loss=0.63716638, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59948969, MSE_maskV_-1.0=0.63667458, val_loss=0.67167395, val_CC_maskV_-1.0=0.57484609, val_MSE_maskV_-1.0=0.66607922, learning_rate=0.001\n", + "Epoch 71/95 - loss=0.63239199, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60364634, MSE_maskV_-1.0=0.63242835, val_loss=0.67006969, val_CC_maskV_-1.0=0.57604551, val_MSE_maskV_-1.0=0.66520035, learning_rate=0.001\n", + "Epoch 81/95 - loss=0.62805319, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60747868, MSE_maskV_-1.0=0.62781209, val_loss=0.66861254, val_CC_maskV_-1.0=0.57766098, val_MSE_maskV_-1.0=0.66322601, learning_rate=0.001\n", + "Epoch 91/95 - loss=0.62512469, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60988206, MSE_maskV_-1.0=0.62553132, val_loss=0.6673649, val_CC_maskV_-1.0=0.5790593, val_MSE_maskV_-1.0=0.66182244, learning_rate=0.001\n", + "Epoch 95/95 - loss=0.62362999, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6104157, MSE_maskV_-1.0=0.62330484, val_loss=0.66423815, val_CC_maskV_-1.0=0.58078772, val_MSE_maskV_-1.0=0.65888774, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:51:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 25.29s\n", + "\u001b[32m2025-05-30 10:51:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:51:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 79 (stopped at 94 epochs).\n", + "\u001b[32m2025-05-30 10:51:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/95 - loss=1.1033449, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.15882042, MSE_maskV_-1.0=1.1044356, val_loss=0.91986507, val_CC_maskV_-1.0=0.29098526, val_MSE_maskV_-1.0=0.91816658, learning_rate=0.001\n", + "Epoch 11/95 - loss=0.70744801, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53748173, MSE_maskV_-1.0=0.70785642, val_loss=0.71497369, val_CC_maskV_-1.0=0.53342086, val_MSE_maskV_-1.0=0.71027994, learning_rate=0.001\n", + "Epoch 21/95 - loss=0.66636574, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57579476, MSE_maskV_-1.0=0.66636789, val_loss=0.68699306, val_CC_maskV_-1.0=0.55934435, val_MSE_maskV_-1.0=0.68208086, learning_rate=0.001\n", + "Epoch 31/95 - loss=0.65003002, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5886786, MSE_maskV_-1.0=0.65024197, val_loss=0.67528695, val_CC_maskV_-1.0=0.57055432, val_MSE_maskV_-1.0=0.67033386, learning_rate=0.001\n", + "Epoch 41/95 - loss=0.6411196, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5960061, MSE_maskV_-1.0=0.64106387, val_loss=0.67437071, val_CC_maskV_-1.0=0.57199335, val_MSE_maskV_-1.0=0.66961336, learning_rate=0.001\n", + "Epoch 51/95 - loss=0.63604534, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59986973, MSE_maskV_-1.0=0.63574427, val_loss=0.66924095, val_CC_maskV_-1.0=0.57656676, val_MSE_maskV_-1.0=0.66389316, learning_rate=0.001\n", + "Epoch 61/95 - loss=0.63189125, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6036045, MSE_maskV_-1.0=0.63139713, val_loss=0.66577059, val_CC_maskV_-1.0=0.5803203, val_MSE_maskV_-1.0=0.6599769, learning_rate=0.001\n", + "Epoch 71/95 - loss=0.62815374, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60679054, MSE_maskV_-1.0=0.62816018, val_loss=0.66509211, val_CC_maskV_-1.0=0.58050865, val_MSE_maskV_-1.0=0.66014189, learning_rate=0.001\n", + "Epoch 81/95 - loss=0.62541628, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60942125, MSE_maskV_-1.0=0.62511647, val_loss=0.66488343, val_CC_maskV_-1.0=0.58117288, val_MSE_maskV_-1.0=0.65926766, learning_rate=0.001\n", + "Epoch 91/95 - loss=0.62350672, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61109102, MSE_maskV_-1.0=0.62379324, val_loss=0.6633274, val_CC_maskV_-1.0=0.5833925, val_MSE_maskV_-1.0=0.65754879, learning_rate=0.001\n", + "Epoch 95/95 - loss=0.62227714, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61142892, MSE_maskV_-1.0=0.62193489, val_loss=0.66133189, val_CC_maskV_-1.0=0.58400404, val_MSE_maskV_-1.0=0.65585494, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:51:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 25.71s\n", + "\u001b[32m2025-05-30 10:51:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.66047198)\n", + "\u001b[32m2025-05-30 10:51:48\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 774us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:51:48\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.622, R2_maskV_-1.0=0.38, CC_maskV_-1.0=0.615\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 779us/step\n", + "51/51 [==============================] - 0s 811us/step\n", + "84/84 [==============================] - 0s 730us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:51:49\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_ACy1HL64U_ErSV16\" (8/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_ACy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 10:51:49\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_KCz1HL64U_ErSV16\" (9/16)\n", + "\u001b[32m2025-05-30 10:51:49\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 10:51:49\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 10:51:49\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 10:51:49\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 10:51:49\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 10:51:49\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 10:51:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:51:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 60 (stopped at 75 epochs).\n", + "\u001b[32m2025-05-30 10:51:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/76 - loss=rnn_1step_loss=0.9994728, rnn_1step_R2_maskV_-1.0=-0.022397399, rnn_1step_CC_maskV_-1.0=0.0016497285, rnn_1step_MSE_maskV_-1.0=0.99947268, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96544558, val_rnn_1step_R2_maskV_-1.0=-0.088199794, val_rnn_1step_CC_maskV_-1.0=0.26391426, learning_rate=0.001\n", + "Epoch 9/76 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.92843419, rnn_1step_R2_maskV_-1.0=0.049528018, rnn_1step_CC_maskV_-1.0=0.43822494, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.87338752, val_rnn_1step_R2_maskV_-1.0=0.017334715, val_rnn_1step_CC_maskV_-1.0=0.44465458, learning_rate=0.001\n", + "Epoch 17/76 - loss=rnn_1step_loss=0.66658837, rnn_1step_R2_maskV_-1.0=0.31195635, rnn_1step_CC_maskV_-1.0=0.57990974, rnn_1step_MSE_maskV_-1.0=0.66658831, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6947825, val_rnn_1step_R2_maskV_-1.0=0.20779251, val_rnn_1step_CC_maskV_-1.0=0.54287612, learning_rate=0.001\n", + "Epoch 25/76 - loss=rnn_1step_loss=0.56649488, rnn_1step_R2_maskV_-1.0=0.4115898, rnn_1step_CC_maskV_-1.0=0.66076136, rnn_1step_MSE_maskV_-1.0=0.56649482, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63601732, val_rnn_1step_R2_maskV_-1.0=0.27330643, val_rnn_1step_CC_maskV_-1.0=0.59459823, learning_rate=0.001\n", + "Epoch 33/76 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.50167692, rnn_1step_R2_maskV_-1.0=0.47770372, rnn_1step_CC_maskV_-1.0=0.7071532, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60935336, val_rnn_1step_R2_maskV_-1.0=0.30336255, val_rnn_1step_CC_maskV_-1.0=0.62021297, learning_rate=0.001\n", + "Epoch 41/76 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.45753047, rnn_1step_R2_maskV_-1.0=0.52324724, rnn_1step_CC_maskV_-1.0=0.73672283, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5837062, val_rnn_1step_R2_maskV_-1.0=0.3330211, val_rnn_1step_CC_maskV_-1.0=0.63801134, learning_rate=0.001\n", + "Epoch 49/76 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41653332, rnn_1step_R2_maskV_-1.0=0.56617022, rnn_1step_CC_maskV_-1.0=0.7637918, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56307268, val_rnn_1step_R2_maskV_-1.0=0.35618412, val_rnn_1step_CC_maskV_-1.0=0.65166873, learning_rate=0.001\n", + "Epoch 57/76 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37974921, rnn_1step_R2_maskV_-1.0=0.60436982, rnn_1step_CC_maskV_-1.0=0.78728765, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55274886, val_rnn_1step_R2_maskV_-1.0=0.36775964, val_rnn_1step_CC_maskV_-1.0=0.66030931, learning_rate=0.001\n", + "Epoch 65/76 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35444418, rnn_1step_R2_maskV_-1.0=0.63067329, rnn_1step_CC_maskV_-1.0=0.80321848, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55253434, val_rnn_1step_R2_maskV_-1.0=0.36806065, val_rnn_1step_CC_maskV_-1.0=0.6617586, learning_rate=0.001\n", + "Epoch 73/76 - loss=rnn_1step_loss=0.33486101, rnn_1step_R2_maskV_-1.0=0.65108323, rnn_1step_CC_maskV_-1.0=0.81529385, rnn_1step_MSE_maskV_-1.0=0.33486098, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55289781, val_rnn_1step_R2_maskV_-1.0=0.36803433, val_rnn_1step_CC_maskV_-1.0=0.66253251, learning_rate=0.001\n", + "Epoch 76/76 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32833967, rnn_1step_R2_maskV_-1.0=0.65786791, rnn_1step_CC_maskV_-1.0=0.81928957, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55275625, val_rnn_1step_R2_maskV_-1.0=0.3684094, val_rnn_1step_CC_maskV_-1.0=0.6628989, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:51:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.24s\n", + "\u001b[32m2025-05-30 10:51:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:52:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 111 (stopped at 126 epochs).\n", + "\u001b[32m2025-05-30 10:52:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/127 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.9994359, rnn_1_1step_R2_maskV_-1.0=-0.022359781, rnn_1_1step_CC_maskV_-1.0=0.033263575, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96535486, val_rnn_1_1step_R2_maskV_-1.0=-0.088122323, val_rnn_1_1step_CC_maskV_-1.0=0.28491378, learning_rate=0.001\n", + "Epoch 14/127 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.77295971, rnn_1_1step_R2_maskV_-1.0=0.20460866, rnn_1_1step_CC_maskV_-1.0=0.48100883, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.76196927, val_rnn_1_1step_R2_maskV_-1.0=0.13258199, val_rnn_1_1step_CC_maskV_-1.0=0.47776818, learning_rate=0.001\n", + "Epoch 27/127 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.55845416, rnn_1_1step_R2_maskV_-1.0=0.41979933, rnn_1_1step_CC_maskV_-1.0=0.66489702, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64468414, val_rnn_1_1step_R2_maskV_-1.0=0.26320881, val_rnn_1_1step_CC_maskV_-1.0=0.59002548, learning_rate=0.001\n", + "Epoch 40/127 - loss=rnn_1_1step_loss=0.44560471, rnn_1_1step_R2_maskV_-1.0=0.53711355, rnn_1_1step_CC_maskV_-1.0=0.74401897, rnn_1_1step_MSE_maskV_-1.0=0.44560477, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56064987, val_rnn_1_1step_R2_maskV_-1.0=0.35905319, val_rnn_1_1step_CC_maskV_-1.0=0.65519035, learning_rate=0.001\n", + "Epoch 53/127 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.35578692, rnn_1_1step_R2_maskV_-1.0=0.63153958, rnn_1_1step_CC_maskV_-1.0=0.80179393, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51072931, val_rnn_1_1step_R2_maskV_-1.0=0.41679853, val_rnn_1_1step_CC_maskV_-1.0=0.69455719, learning_rate=0.001\n", + "Epoch 66/127 - loss=rnn_1_1step_loss=0.30375817, rnn_1_1step_R2_maskV_-1.0=0.68594033, rnn_1_1step_CC_maskV_-1.0=0.83351427, rnn_1_1step_MSE_maskV_-1.0=0.30375814, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50017017, val_rnn_1_1step_R2_maskV_-1.0=0.4293308, val_rnn_1_1step_CC_maskV_-1.0=0.70559967, learning_rate=0.001\n", + "Epoch 79/127 - loss=rnn_1_1step_loss=0.27129877, rnn_1_1step_R2_maskV_-1.0=0.71959388, rnn_1_1step_CC_maskV_-1.0=0.85275674, rnn_1_1step_MSE_maskV_-1.0=0.27129874, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49080646, val_rnn_1_1step_R2_maskV_-1.0=0.43919879, val_rnn_1_1step_CC_maskV_-1.0=0.71447825, learning_rate=0.001\n", + "Epoch 92/127 - loss=rnn_1_1step_loss=0.24972259, rnn_1_1step_R2_maskV_-1.0=0.74190003, rnn_1_1step_CC_maskV_-1.0=0.86533922, rnn_1_1step_MSE_maskV_-1.0=0.24972256, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48500466, val_rnn_1_1step_R2_maskV_-1.0=0.44523138, val_rnn_1_1step_CC_maskV_-1.0=0.71976042, learning_rate=0.001\n", + "Epoch 105/127 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.23720098, rnn_1_1step_R2_maskV_-1.0=0.75473952, rnn_1_1step_CC_maskV_-1.0=0.87265885, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48369956, val_rnn_1_1step_R2_maskV_-1.0=0.44645941, val_rnn_1_1step_CC_maskV_-1.0=0.72185957, learning_rate=0.001\n", + "Epoch 118/127 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.21900664, rnn_1_1step_R2_maskV_-1.0=0.77372712, rnn_1_1step_CC_maskV_-1.0=0.88298124, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47512746, val_rnn_1_1step_R2_maskV_-1.0=0.45640975, val_rnn_1_1step_CC_maskV_-1.0=0.72642457, learning_rate=0.001\n", + "Epoch 127/127 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.21192734, rnn_1_1step_R2_maskV_-1.0=0.78093874, rnn_1_1step_CC_maskV_-1.0=0.886989, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4767746, val_rnn_1_1step_R2_maskV_-1.0=0.45466042, val_rnn_1_1step_CC_maskV_-1.0=0.72476327, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:52:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.08s\n", + "\u001b[32m2025-05-30 10:52:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.47085252)\n", + "\u001b[32m2025-05-30 10:52:16\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.193, R2_maskV_-1.0=0.807, CC_maskV_-1.0=0.898\n", + "\u001b[32m2025-05-30 10:52:16\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.418, R2_maskV_-1.0=0.535, CC_maskV_-1.0=0.762\n", + "\u001b[32m2025-05-30 10:52:16\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 10:52:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:53:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 295 (stopped at 310 epochs).\n", + "\u001b[32m2025-05-30 10:53:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/311 - loss=2.2601564, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.032124374, MSE_maskV_-1.0=2.2587399, val_loss=1.1289032, val_CC_maskV_-1.0=0.077924587, val_MSE_maskV_-1.0=1.126714, learning_rate=0.001\n", + "Epoch 33/311 - loss=0.88393253, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34351063, MSE_maskV_-1.0=0.883497, val_loss=0.88718975, val_CC_maskV_-1.0=0.34830433, val_MSE_maskV_-1.0=0.88381028, learning_rate=0.001\n", + "Epoch 65/311 - loss=0.85855234, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38022423, MSE_maskV_-1.0=0.8590312, val_loss=0.86773109, val_CC_maskV_-1.0=0.3734861, val_MSE_maskV_-1.0=0.86557084, learning_rate=0.001\n", + "Epoch 97/311 - loss=0.84422463, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39764908, MSE_maskV_-1.0=0.84336662, val_loss=0.85330307, val_CC_maskV_-1.0=0.39441654, val_MSE_maskV_-1.0=0.85052186, learning_rate=0.001\n", + "Epoch 129/311 - loss=0.8341285, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41071814, MSE_maskV_-1.0=0.83369356, val_loss=0.84583646, val_CC_maskV_-1.0=0.40351799, val_MSE_maskV_-1.0=0.84302968, learning_rate=0.001\n", + "Epoch 161/311 - loss=0.82687354, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41912004, MSE_maskV_-1.0=0.82676524, val_loss=0.84114093, val_CC_maskV_-1.0=0.40820125, val_MSE_maskV_-1.0=0.83804381, learning_rate=0.001\n", + "Epoch 193/311 - loss=0.82163113, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42484197, MSE_maskV_-1.0=0.82092625, val_loss=0.8334651, val_CC_maskV_-1.0=0.41752642, val_MSE_maskV_-1.0=0.83084279, learning_rate=0.001\n", + "Epoch 225/311 - loss=0.81727725, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42989254, MSE_maskV_-1.0=0.81779778, val_loss=0.83173805, val_CC_maskV_-1.0=0.41894749, val_MSE_maskV_-1.0=0.82924116, learning_rate=0.001\n", + "Epoch 257/311 - loss=0.81386936, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43318763, MSE_maskV_-1.0=0.81308621, val_loss=0.82817048, val_CC_maskV_-1.0=0.42272419, val_MSE_maskV_-1.0=0.82614946, learning_rate=0.001\n", + "Epoch 289/311 - loss=0.8105908, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43740898, MSE_maskV_-1.0=0.81030661, val_loss=0.82633471, val_CC_maskV_-1.0=0.42500117, val_MSE_maskV_-1.0=0.82367671, learning_rate=0.001\n", + "Epoch 311/311 - loss=0.8099094, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43704945, MSE_maskV_-1.0=0.81314862, val_loss=0.82526779, val_CC_maskV_-1.0=0.42632699, val_MSE_maskV_-1.0=0.8225444, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:53:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 74.34s\n", + "\u001b[32m2025-05-30 10:53:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:54:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 295 (stopped at 310 epochs).\n", + "\u001b[32m2025-05-30 10:54:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/311 - loss=2.7225444, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.016344491, MSE_maskV_-1.0=2.7196403, val_loss=1.1667256, val_CC_maskV_-1.0=0.057462037, val_MSE_maskV_-1.0=1.1630062, learning_rate=0.001\n", + "Epoch 33/311 - loss=0.88267016, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34501287, MSE_maskV_-1.0=0.88224649, val_loss=0.88613343, val_CC_maskV_-1.0=0.35044682, val_MSE_maskV_-1.0=0.88251573, learning_rate=0.001\n", + "Epoch 65/311 - loss=0.85736918, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38191348, MSE_maskV_-1.0=0.85780972, val_loss=0.86662757, val_CC_maskV_-1.0=0.37570199, val_MSE_maskV_-1.0=0.86426401, learning_rate=0.001\n", + "Epoch 97/311 - loss=0.84296644, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39942944, MSE_maskV_-1.0=0.84210521, val_loss=0.85203123, val_CC_maskV_-1.0=0.39694622, val_MSE_maskV_-1.0=0.84900481, learning_rate=0.001\n", + "Epoch 129/311 - loss=0.83283323, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41251507, MSE_maskV_-1.0=0.83239377, val_loss=0.84450847, val_CC_maskV_-1.0=0.4059101, val_MSE_maskV_-1.0=0.84152937, learning_rate=0.001\n", + "Epoch 161/311 - loss=0.82557583, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42078936, MSE_maskV_-1.0=0.82550496, val_loss=0.83981794, val_CC_maskV_-1.0=0.41044483, val_MSE_maskV_-1.0=0.836573, learning_rate=0.001\n", + "Epoch 193/311 - loss=0.82041556, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42645669, MSE_maskV_-1.0=0.81970567, val_loss=0.83210909, val_CC_maskV_-1.0=0.4196915, val_MSE_maskV_-1.0=0.82941443, learning_rate=0.001\n", + "Epoch 225/311 - loss=0.81612086, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43134847, MSE_maskV_-1.0=0.81666178, val_loss=0.83048415, val_CC_maskV_-1.0=0.42082679, val_MSE_maskV_-1.0=0.82793862, learning_rate=0.001\n", + "Epoch 257/311 - loss=0.81278688, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43451524, MSE_maskV_-1.0=0.81199545, val_loss=0.82689822, val_CC_maskV_-1.0=0.42459154, val_MSE_maskV_-1.0=0.82480687, learning_rate=0.001\n", + "Epoch 289/311 - loss=0.80957407, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4386529, MSE_maskV_-1.0=0.80930352, val_loss=0.82516879, val_CC_maskV_-1.0=0.42664552, val_MSE_maskV_-1.0=0.82247341, learning_rate=0.001\n", + "Epoch 311/311 - loss=0.80895483, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43819618, MSE_maskV_-1.0=0.81219512, val_loss=0.82418501, val_CC_maskV_-1.0=0.42783222, val_MSE_maskV_-1.0=0.82142019, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:54:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 74.60s\n", + "\u001b[32m2025-05-30 10:54:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.82145828)\n", + "\u001b[32m2025-05-30 10:54:45\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 747us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:54:45\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.809, R2_maskV_-1.0=0.191, CC_maskV_-1.0=0.438\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 740us/step\n", + "51/51 [==============================] - 0s 779us/step\n", + "84/84 [==============================] - 0s 704us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:54:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_KCz1HL64U_ErSV16\" (9/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_KCz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 10:54:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_KCy1HL64U_ErSV16\" (10/16)\n", + "\u001b[32m2025-05-30 10:54:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 10:54:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 10:54:46\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 10:54:46\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 10:54:46\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 10:54:46\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 10:54:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:54:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 89 (stopped at 104 epochs).\n", + "\u001b[32m2025-05-30 10:54:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.99950427, rnn_1step_R2_maskV_-1.0=-0.022426631, rnn_1step_CC_maskV_-1.0=0.0088448431, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.964351, val_rnn_1step_R2_maskV_-1.0=-0.087148845, val_rnn_1step_CC_maskV_-1.0=0.2401045, learning_rate=0.001\n", + "Epoch 12/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.83969212, rnn_1step_R2_maskV_-1.0=0.14014015, rnn_1step_CC_maskV_-1.0=0.40293586, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.78141326, val_rnn_1step_R2_maskV_-1.0=0.1080474, val_rnn_1step_CC_maskV_-1.0=0.42760777, learning_rate=0.001\n", + "Epoch 23/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.65040386, rnn_1step_R2_maskV_-1.0=0.33150673, rnn_1step_CC_maskV_-1.0=0.58986318, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.68160486, val_rnn_1step_R2_maskV_-1.0=0.22453354, val_rnn_1step_CC_maskV_-1.0=0.53992051, learning_rate=0.001\n", + "Epoch 34/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.48224866, rnn_1step_R2_maskV_-1.0=0.50429547, rnn_1step_CC_maskV_-1.0=0.71741027, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56329101, val_rnn_1step_R2_maskV_-1.0=0.35672927, val_rnn_1step_CC_maskV_-1.0=0.64914757, learning_rate=0.001\n", + "Epoch 45/105 - loss=rnn_1step_loss=0.39974055, rnn_1step_R2_maskV_-1.0=0.5890851, rnn_1step_CC_maskV_-1.0=0.7727707, rnn_1step_MSE_maskV_-1.0=0.39974052, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51449299, val_rnn_1step_R2_maskV_-1.0=0.40936852, val_rnn_1step_CC_maskV_-1.0=0.68915945, learning_rate=0.001\n", + "Epoch 56/105 - loss=rnn_1step_loss=0.36084577, rnn_1step_R2_maskV_-1.0=0.6288507, rnn_1step_CC_maskV_-1.0=0.79781663, rnn_1step_MSE_maskV_-1.0=0.36084574, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50181943, val_rnn_1step_R2_maskV_-1.0=0.42430466, val_rnn_1step_CC_maskV_-1.0=0.69884419, learning_rate=0.001\n", + "Epoch 67/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31184983, rnn_1step_R2_maskV_-1.0=0.67873502, rnn_1step_CC_maskV_-1.0=0.82841825, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47585389, val_rnn_1step_R2_maskV_-1.0=0.45627058, val_rnn_1step_CC_maskV_-1.0=0.71892887, learning_rate=0.001\n", + "Epoch 78/105 - loss=rnn_1step_loss=0.26931658, rnn_1step_R2_maskV_-1.0=0.72220844, rnn_1step_CC_maskV_-1.0=0.85359943, rnn_1step_MSE_maskV_-1.0=0.26931655, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4608916, val_rnn_1step_R2_maskV_-1.0=0.47507188, val_rnn_1step_CC_maskV_-1.0=0.73210168, learning_rate=0.001\n", + "Epoch 89/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.25484279, rnn_1step_R2_maskV_-1.0=0.73704237, rnn_1step_CC_maskV_-1.0=0.86257142, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45062652, val_rnn_1step_R2_maskV_-1.0=0.48720613, val_rnn_1step_CC_maskV_-1.0=0.73617429, learning_rate=0.001\n", + "Epoch 100/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.24264592, rnn_1step_R2_maskV_-1.0=0.74968565, rnn_1step_CC_maskV_-1.0=0.86958605, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47112623, val_rnn_1step_R2_maskV_-1.0=0.46251285, val_rnn_1step_CC_maskV_-1.0=0.72798449, learning_rate=0.001\n", + "Epoch 105/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.23443699, rnn_1step_R2_maskV_-1.0=0.75794446, rnn_1step_CC_maskV_-1.0=0.87403256, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47513792, val_rnn_1step_R2_maskV_-1.0=0.45800906, val_rnn_1step_CC_maskV_-1.0=0.72721899, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:54:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.41s\n", + "\u001b[32m2025-05-30 10:54:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:55:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 107 (stopped at 122 epochs).\n", + "\u001b[32m2025-05-30 10:55:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/123 - loss=rnn_1_1step_loss=0.99869603, rnn_1_1step_R2_maskV_-1.0=-0.02160342, rnn_1_1step_CC_maskV_-1.0=0.11256957, rnn_1_1step_MSE_maskV_-1.0=0.99869609, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96561402, val_rnn_1_1step_R2_maskV_-1.0=-0.08858259, val_rnn_1_1step_CC_maskV_-1.0=0.16747876, learning_rate=0.001\n", + "Epoch 14/123 - loss=rnn_1_1step_loss=0.73034769, rnn_1_1step_R2_maskV_-1.0=0.25057673, rnn_1_1step_CC_maskV_-1.0=0.52159679, rnn_1_1step_MSE_maskV_-1.0=0.73034763, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.74257714, val_rnn_1_1step_R2_maskV_-1.0=0.15122926, val_rnn_1_1step_CC_maskV_-1.0=0.49286178, learning_rate=0.001\n", + "Epoch 27/123 - loss=rnn_1_1step_loss=0.55878091, rnn_1_1step_R2_maskV_-1.0=0.42177337, rnn_1_1step_CC_maskV_-1.0=0.66478765, rnn_1_1step_MSE_maskV_-1.0=0.55878097, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62773412, val_rnn_1_1step_R2_maskV_-1.0=0.27997383, val_rnn_1_1step_CC_maskV_-1.0=0.60132021, learning_rate=0.001\n", + "Epoch 40/123 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44016501, rnn_1_1step_R2_maskV_-1.0=0.54525173, rnn_1_1step_CC_maskV_-1.0=0.74754238, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56565744, val_rnn_1_1step_R2_maskV_-1.0=0.35267386, val_rnn_1_1step_CC_maskV_-1.0=0.65377647, learning_rate=0.001\n", + "Epoch 53/123 - loss=rnn_1_1step_loss=0.34902653, rnn_1_1step_R2_maskV_-1.0=0.63980746, rnn_1_1step_CC_maskV_-1.0=0.80583298, rnn_1_1step_MSE_maskV_-1.0=0.34902656, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51050562, val_rnn_1_1step_R2_maskV_-1.0=0.41687846, val_rnn_1_1step_CC_maskV_-1.0=0.69372171, learning_rate=0.001\n", + "Epoch 66/123 - loss=rnn_1_1step_loss=0.29829422, rnn_1_1step_R2_maskV_-1.0=0.69272327, rnn_1_1step_CC_maskV_-1.0=0.83659047, rnn_1_1step_MSE_maskV_-1.0=0.29829425, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50035906, val_rnn_1_1step_R2_maskV_-1.0=0.42811307, val_rnn_1_1step_CC_maskV_-1.0=0.7059139, learning_rate=0.001\n", + "Epoch 79/123 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.26756021, rnn_1_1step_R2_maskV_-1.0=0.72439933, rnn_1_1step_CC_maskV_-1.0=0.85460329, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49421534, val_rnn_1_1step_R2_maskV_-1.0=0.43444294, val_rnn_1_1step_CC_maskV_-1.0=0.71366614, learning_rate=0.001\n", + "Epoch 92/123 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.24933605, rnn_1_1step_R2_maskV_-1.0=0.74305975, rnn_1_1step_CC_maskV_-1.0=0.8651585, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49318609, val_rnn_1_1step_R2_maskV_-1.0=0.43525574, val_rnn_1_1step_CC_maskV_-1.0=0.71524346, learning_rate=0.001\n", + "Epoch 105/123 - loss=rnn_1_1step_loss=0.23676743, rnn_1_1step_R2_maskV_-1.0=0.75597394, rnn_1_1step_CC_maskV_-1.0=0.87238669, rnn_1_1step_MSE_maskV_-1.0=0.23676746, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49257192, val_rnn_1_1step_R2_maskV_-1.0=0.43575495, val_rnn_1_1step_CC_maskV_-1.0=0.71565312, learning_rate=0.001\n", + "Epoch 118/123 - loss=rnn_1_1step_loss=0.22659159, rnn_1_1step_R2_maskV_-1.0=0.76642126, rnn_1_1step_CC_maskV_-1.0=0.87824929, rnn_1_1step_MSE_maskV_-1.0=0.22659157, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49332991, val_rnn_1_1step_R2_maskV_-1.0=0.43487042, val_rnn_1_1step_CC_maskV_-1.0=0.71542013, learning_rate=0.001\n", + "Epoch 123/123 - loss=rnn_1_1step_loss=0.22511901, rnn_1_1step_R2_maskV_-1.0=0.76776481, rnn_1_1step_CC_maskV_-1.0=0.87898874, rnn_1_1step_MSE_maskV_-1.0=0.22511904, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49589929, val_rnn_1_1step_R2_maskV_-1.0=0.43164024, val_rnn_1_1step_CC_maskV_-1.0=0.71346635, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:55:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 13.94s\n", + "\u001b[32m2025-05-30 10:55:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.45062652)\n", + "\u001b[32m2025-05-30 10:55:14\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.215, R2_maskV_-1.0=0.785, CC_maskV_-1.0=0.886\n", + "\u001b[32m2025-05-30 10:55:14\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.426, R2_maskV_-1.0=0.529, CC_maskV_-1.0=0.755\n", + "\u001b[32m2025-05-30 10:55:14\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 10:55:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:55:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 147 (stopped at 162 epochs).\n", + "\u001b[32m2025-05-30 10:55:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/163 - loss=1.1552845, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.11285377, MSE_maskV_-1.0=1.1568252, val_loss=0.97976643, val_CC_maskV_-1.0=0.17583984, val_MSE_maskV_-1.0=0.97718751, learning_rate=0.001\n", + "Epoch 18/163 - loss=0.84656215, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39289927, MSE_maskV_-1.0=0.84653741, val_loss=0.86816341, val_CC_maskV_-1.0=0.37580889, val_MSE_maskV_-1.0=0.86653292, learning_rate=0.001\n", + "Epoch 35/163 - loss=0.8073957, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44039088, MSE_maskV_-1.0=0.80727601, val_loss=0.83922142, val_CC_maskV_-1.0=0.41166911, val_MSE_maskV_-1.0=0.83798492, learning_rate=0.001\n", + "Epoch 52/163 - loss=0.78529769, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46418858, MSE_maskV_-1.0=0.7858246, val_loss=0.82326138, val_CC_maskV_-1.0=0.43114388, val_MSE_maskV_-1.0=0.82194614, learning_rate=0.001\n", + "Epoch 69/163 - loss=0.77254987, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47820944, MSE_maskV_-1.0=0.7729125, val_loss=0.80872315, val_CC_maskV_-1.0=0.44714472, val_MSE_maskV_-1.0=0.80711097, learning_rate=0.001\n", + "Epoch 86/163 - loss=0.7636556, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48664603, MSE_maskV_-1.0=0.76339406, val_loss=0.80424947, val_CC_maskV_-1.0=0.45340848, val_MSE_maskV_-1.0=0.80188042, learning_rate=0.001\n", + "Epoch 103/163 - loss=0.75690883, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49346811, MSE_maskV_-1.0=0.75634438, val_loss=0.79977953, val_CC_maskV_-1.0=0.4577769, val_MSE_maskV_-1.0=0.79757988, learning_rate=0.001\n", + "Epoch 120/163 - loss=0.75129759, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49879062, MSE_maskV_-1.0=0.75143301, val_loss=0.79673547, val_CC_maskV_-1.0=0.46100664, val_MSE_maskV_-1.0=0.79464334, learning_rate=0.001\n", + "Epoch 137/163 - loss=0.74742252, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50333893, MSE_maskV_-1.0=0.74708921, val_loss=0.79169506, val_CC_maskV_-1.0=0.46653557, val_MSE_maskV_-1.0=0.78913391, learning_rate=0.001\n", + "Epoch 154/163 - loss=0.74295837, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50690216, MSE_maskV_-1.0=0.74283445, val_loss=0.78810823, val_CC_maskV_-1.0=0.47029698, val_MSE_maskV_-1.0=0.7861945, learning_rate=0.001\n", + "Epoch 163/163 - loss=0.74202228, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50827372, MSE_maskV_-1.0=0.74153793, val_loss=0.79216552, val_CC_maskV_-1.0=0.46615249, val_MSE_maskV_-1.0=0.790066, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:55:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 42.39s\n", + "\u001b[32m2025-05-30 10:55:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:56:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 144 (stopped at 159 epochs).\n", + "\u001b[32m2025-05-30 10:56:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/160 - loss=1.1510147, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.10963125, MSE_maskV_-1.0=1.1526023, val_loss=0.97194171, val_CC_maskV_-1.0=0.18840225, val_MSE_maskV_-1.0=0.97041708, learning_rate=0.001\n", + "Epoch 17/160 - loss=0.84003627, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40223536, MSE_maskV_-1.0=0.83946788, val_loss=0.8597126, val_CC_maskV_-1.0=0.38792533, val_MSE_maskV_-1.0=0.85754281, learning_rate=0.001\n", + "Epoch 33/160 - loss=0.79966795, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44879869, MSE_maskV_-1.0=0.79938382, val_loss=0.82828963, val_CC_maskV_-1.0=0.42477462, val_MSE_maskV_-1.0=0.82689631, learning_rate=0.001\n", + "Epoch 49/160 - loss=0.78226906, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4669359, MSE_maskV_-1.0=0.78220522, val_loss=0.81084061, val_CC_maskV_-1.0=0.44379482, val_MSE_maskV_-1.0=0.80953479, learning_rate=0.001\n", + "Epoch 65/160 - loss=0.7723664, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47814569, MSE_maskV_-1.0=0.7728796, val_loss=0.80514419, val_CC_maskV_-1.0=0.45045784, val_MSE_maskV_-1.0=0.80364406, learning_rate=0.001\n", + "Epoch 81/160 - loss=0.76594889, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4841131, MSE_maskV_-1.0=0.76593846, val_loss=0.80255449, val_CC_maskV_-1.0=0.45352918, val_MSE_maskV_-1.0=0.80158556, learning_rate=0.001\n", + "Epoch 97/160 - loss=0.75880623, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49180037, MSE_maskV_-1.0=0.75788599, val_loss=0.79842001, val_CC_maskV_-1.0=0.45804131, val_MSE_maskV_-1.0=0.79704905, learning_rate=0.001\n", + "Epoch 113/160 - loss=0.75341332, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49709067, MSE_maskV_-1.0=0.75562835, val_loss=0.79417497, val_CC_maskV_-1.0=0.46453094, val_MSE_maskV_-1.0=0.79248077, learning_rate=0.001\n", + "Epoch 129/160 - loss=0.7509554, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50003248, MSE_maskV_-1.0=0.7503885, val_loss=0.79018474, val_CC_maskV_-1.0=0.46672159, val_MSE_maskV_-1.0=0.78862989, learning_rate=0.001\n", + "Epoch 145/160 - loss=0.74678677, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5031808, MSE_maskV_-1.0=0.74683869, val_loss=0.78768003, val_CC_maskV_-1.0=0.46970233, val_MSE_maskV_-1.0=0.78651094, learning_rate=0.001\n", + "Epoch 160/160 - loss=0.74319535, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50722468, MSE_maskV_-1.0=0.74281007, val_loss=0.78429425, val_CC_maskV_-1.0=0.47262803, val_MSE_maskV_-1.0=0.78344721, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:56:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 42.09s\n", + "\u001b[32m2025-05-30 10:56:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.7817995)\n", + "\u001b[32m2025-05-30 10:56:39\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 853us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:56:39\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.743, R2_maskV_-1.0=0.257, CC_maskV_-1.0=0.507\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 865us/step\n", + "51/51 [==============================] - 0s 916us/step\n", + "84/84 [==============================] - 0s 754us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:56:40\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_KCy1HL64U_ErSV16\" (10/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_KCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 10:56:40\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_CzCy1HL64U_ErSV16\" (11/16)\n", + "\u001b[32m2025-05-30 10:56:40\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_CzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 10:56:40\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 10:56:40\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 10:56:40\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 10:56:40\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 10:56:40\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 10:56:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:57:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 200 (stopped at 215 epochs).\n", + "\u001b[32m2025-05-30 10:57:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/216 - loss=rnn_1step_loss=0.99890679, rnn_1step_R2_maskV_-1.0=-0.021837089, rnn_1step_CC_maskV_-1.0=0.080994837, rnn_1step_MSE_maskV_-1.0=0.99890673, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96422482, val_rnn_1step_R2_maskV_-1.0=-0.086929083, val_rnn_1step_CC_maskV_-1.0=0.23237434, learning_rate=0.001\n", + "Epoch 23/216 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.64148664, rnn_1step_R2_maskV_-1.0=0.3349174, rnn_1step_CC_maskV_-1.0=0.60011733, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.68292403, val_rnn_1step_R2_maskV_-1.0=0.22014122, val_rnn_1step_CC_maskV_-1.0=0.54965597, learning_rate=0.001\n", + "Epoch 45/216 - loss=rnn_1step_loss=0.53598708, rnn_1step_R2_maskV_-1.0=0.44450802, rnn_1step_CC_maskV_-1.0=0.68110955, rnn_1step_MSE_maskV_-1.0=0.53598702, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60623676, val_rnn_1step_R2_maskV_-1.0=0.30721998, val_rnn_1step_CC_maskV_-1.0=0.61476606, learning_rate=0.001\n", + "Epoch 67/216 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.46268144, rnn_1step_R2_maskV_-1.0=0.52158535, rnn_1step_CC_maskV_-1.0=0.73198718, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57774305, val_rnn_1step_R2_maskV_-1.0=0.33697551, val_rnn_1step_CC_maskV_-1.0=0.64383441, learning_rate=0.001\n", + "Epoch 89/216 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41841719, rnn_1step_R2_maskV_-1.0=0.56719816, rnn_1step_CC_maskV_-1.0=0.76153487, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55483472, val_rnn_1step_R2_maskV_-1.0=0.36104798, val_rnn_1step_CC_maskV_-1.0=0.66543764, learning_rate=0.001\n", + "Epoch 111/216 - loss=rnn_1step_loss=0.38216758, rnn_1step_R2_maskV_-1.0=0.60457295, rnn_1step_CC_maskV_-1.0=0.78500617, rnn_1step_MSE_maskV_-1.0=0.38216755, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53169924, val_rnn_1step_R2_maskV_-1.0=0.38803461, val_rnn_1step_CC_maskV_-1.0=0.68456203, learning_rate=0.001\n", + "Epoch 133/216 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.36052528, rnn_1step_R2_maskV_-1.0=0.62712479, rnn_1step_CC_maskV_-1.0=0.79852211, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5141477, val_rnn_1step_R2_maskV_-1.0=0.408562, val_rnn_1step_CC_maskV_-1.0=0.6989696, learning_rate=0.001\n", + "Epoch 155/216 - loss=rnn_1step_loss=0.35180882, rnn_1step_R2_maskV_-1.0=0.63626945, rnn_1step_CC_maskV_-1.0=0.80386615, rnn_1step_MSE_maskV_-1.0=0.35180885, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50625855, val_rnn_1step_R2_maskV_-1.0=0.41768324, val_rnn_1step_CC_maskV_-1.0=0.70526928, learning_rate=0.001\n", + "Epoch 177/216 - loss=rnn_1step_loss=0.34551248, rnn_1step_R2_maskV_-1.0=0.64279634, rnn_1step_CC_maskV_-1.0=0.80766022, rnn_1step_MSE_maskV_-1.0=0.34551245, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50159019, val_rnn_1step_R2_maskV_-1.0=0.42326832, val_rnn_1step_CC_maskV_-1.0=0.70910013, learning_rate=0.001\n", + "Epoch 199/216 - loss=rnn_1step_loss=0.33962402, rnn_1step_R2_maskV_-1.0=0.64889061, rnn_1step_CC_maskV_-1.0=0.81125331, rnn_1step_MSE_maskV_-1.0=0.33962405, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50003117, val_rnn_1step_R2_maskV_-1.0=0.42547178, val_rnn_1step_CC_maskV_-1.0=0.71042126, learning_rate=0.001\n", + "Epoch 216/216 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33530787, rnn_1step_R2_maskV_-1.0=0.65336919, rnn_1step_CC_maskV_-1.0=0.81387532, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49982867, val_rnn_1step_R2_maskV_-1.0=0.42601353, val_rnn_1step_CC_maskV_-1.0=0.71097761, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:57:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 22.24s\n", + "\u001b[32m2025-05-30 10:57:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:57:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 96 (stopped at 111 epochs).\n", + "\u001b[32m2025-05-30 10:57:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/112 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.99916083, rnn_1_1step_R2_maskV_-1.0=-0.022107247, rnn_1_1step_CC_maskV_-1.0=0.04826235, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96465141, val_rnn_1_1step_R2_maskV_-1.0=-0.087359875, val_rnn_1_1step_CC_maskV_-1.0=0.25939637, learning_rate=0.001\n", + "Epoch 13/112 - loss=rnn_1_1step_loss=0.81090736, rnn_1_1step_R2_maskV_-1.0=0.16841266, rnn_1_1step_CC_maskV_-1.0=0.43777308, rnn_1_1step_MSE_maskV_-1.0=0.8109073, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.80303687, val_rnn_1_1step_R2_maskV_-1.0=0.091863304, val_rnn_1_1step_CC_maskV_-1.0=0.43922266, learning_rate=0.001\n", + "Epoch 25/112 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.61438805, rnn_1_1step_R2_maskV_-1.0=0.365307, rnn_1_1step_CC_maskV_-1.0=0.62218577, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64553708, val_rnn_1_1step_R2_maskV_-1.0=0.26170522, val_rnn_1_1step_CC_maskV_-1.0=0.58140755, learning_rate=0.001\n", + "Epoch 37/112 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.52369142, rnn_1_1step_R2_maskV_-1.0=0.45995724, rnn_1_1step_CC_maskV_-1.0=0.68996727, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5848453, val_rnn_1_1step_R2_maskV_-1.0=0.33082259, val_rnn_1_1step_CC_maskV_-1.0=0.63229197, learning_rate=0.001\n", + "Epoch 49/112 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.47243729, rnn_1_1step_R2_maskV_-1.0=0.5130049, rnn_1_1step_CC_maskV_-1.0=0.72524399, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56087226, val_rnn_1_1step_R2_maskV_-1.0=0.35808915, val_rnn_1_1step_CC_maskV_-1.0=0.65700817, learning_rate=0.001\n", + "Epoch 61/112 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.43698898, rnn_1_1step_R2_maskV_-1.0=0.54939461, rnn_1_1step_CC_maskV_-1.0=0.74901664, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54129332, val_rnn_1_1step_R2_maskV_-1.0=0.37975973, val_rnn_1_1step_CC_maskV_-1.0=0.67509568, learning_rate=0.001\n", + "Epoch 73/112 - loss=rnn_1_1step_loss=0.40222868, rnn_1_1step_R2_maskV_-1.0=0.58485162, rnn_1_1step_CC_maskV_-1.0=0.77179563, rnn_1_1step_MSE_maskV_-1.0=0.40222865, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52620727, val_rnn_1_1step_R2_maskV_-1.0=0.39532369, val_rnn_1_1step_CC_maskV_-1.0=0.68959588, learning_rate=0.001\n", + "Epoch 85/112 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38136435, rnn_1_1step_R2_maskV_-1.0=0.60598105, rnn_1_1step_CC_maskV_-1.0=0.78516603, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51939285, val_rnn_1_1step_R2_maskV_-1.0=0.40253428, val_rnn_1_1step_CC_maskV_-1.0=0.69634241, learning_rate=0.001\n", + "Epoch 97/112 - loss=rnn_1_1step_loss=0.37264279, rnn_1_1step_R2_maskV_-1.0=0.61497784, rnn_1_1step_CC_maskV_-1.0=0.79071295, rnn_1_1step_MSE_maskV_-1.0=0.37264276, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51798266, val_rnn_1_1step_R2_maskV_-1.0=0.40410477, val_rnn_1_1step_CC_maskV_-1.0=0.69797879, learning_rate=0.001\n", + "Epoch 109/112 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36706904, rnn_1_1step_R2_maskV_-1.0=0.62073219, rnn_1_1step_CC_maskV_-1.0=0.7942341, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51939803, val_rnn_1_1step_R2_maskV_-1.0=0.40235519, val_rnn_1_1step_CC_maskV_-1.0=0.69778663, learning_rate=0.001\n", + "Epoch 112/112 - loss=rnn_1_1step_loss=0.36594746, rnn_1_1step_R2_maskV_-1.0=0.62188977, rnn_1_1step_CC_maskV_-1.0=0.7949487, rnn_1_1step_MSE_maskV_-1.0=0.36594743, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51970381, val_rnn_1_1step_R2_maskV_-1.0=0.40198088, val_rnn_1_1step_CC_maskV_-1.0=0.697667, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:57:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 13.33s\n", + "\u001b[32m2025-05-30 10:57:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.49949703)\n", + "\u001b[32m2025-05-30 10:57:17\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.298, R2_maskV_-1.0=0.701, CC_maskV_-1.0=0.838\n", + "\u001b[32m2025-05-30 10:57:17\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.474, R2_maskV_-1.0=0.469, CC_maskV_-1.0=0.733\n", + "\u001b[32m2025-05-30 10:57:17\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 10:57:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:57:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 101 (stopped at 116 epochs).\n", + "\u001b[32m2025-05-30 10:57:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/117 - loss=1.8352954, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.069116674, MSE_maskV_-1.0=1.8346745, val_loss=1.057552, val_CC_maskV_-1.0=0.15001963, val_MSE_maskV_-1.0=1.0539672, learning_rate=0.001\n", + "Epoch 13/117 - loss=0.74932909, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49860775, MSE_maskV_-1.0=0.74888587, val_loss=0.76093662, val_CC_maskV_-1.0=0.48896131, val_MSE_maskV_-1.0=0.75936311, learning_rate=0.001\n", + "Epoch 25/117 - loss=0.68881273, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55662185, MSE_maskV_-1.0=0.68975472, val_loss=0.71085197, val_CC_maskV_-1.0=0.53666991, val_MSE_maskV_-1.0=0.70942253, learning_rate=0.001\n", + "Epoch 37/117 - loss=0.6626879, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57833165, MSE_maskV_-1.0=0.66313499, val_loss=0.69416749, val_CC_maskV_-1.0=0.55213022, val_MSE_maskV_-1.0=0.69251722, learning_rate=0.001\n", + "Epoch 49/117 - loss=0.64830697, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59139621, MSE_maskV_-1.0=0.64812326, val_loss=0.68147767, val_CC_maskV_-1.0=0.56227696, val_MSE_maskV_-1.0=0.68078119, learning_rate=0.001\n", + "Epoch 61/117 - loss=0.64094937, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59675241, MSE_maskV_-1.0=0.6403904, val_loss=0.67782521, val_CC_maskV_-1.0=0.56610441, val_MSE_maskV_-1.0=0.67703539, learning_rate=0.001\n", + "Epoch 73/117 - loss=0.63480216, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60094482, MSE_maskV_-1.0=0.63460976, val_loss=0.6741823, val_CC_maskV_-1.0=0.56980288, val_MSE_maskV_-1.0=0.67343628, learning_rate=0.001\n", + "Epoch 85/117 - loss=0.63027114, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60561818, MSE_maskV_-1.0=0.63022745, val_loss=0.66648954, val_CC_maskV_-1.0=0.5753386, val_MSE_maskV_-1.0=0.66597033, learning_rate=0.001\n", + "Epoch 97/117 - loss=0.62653726, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60903579, MSE_maskV_-1.0=0.62594706, val_loss=0.67202622, val_CC_maskV_-1.0=0.57125574, val_MSE_maskV_-1.0=0.67162323, learning_rate=0.001\n", + "Epoch 109/117 - loss=0.62387151, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61072516, MSE_maskV_-1.0=0.62371087, val_loss=0.66745299, val_CC_maskV_-1.0=0.57551765, val_MSE_maskV_-1.0=0.66681796, learning_rate=0.001\n", + "Epoch 117/117 - loss=0.62187022, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61191666, MSE_maskV_-1.0=0.62176698, val_loss=0.66555196, val_CC_maskV_-1.0=0.57659799, val_MSE_maskV_-1.0=0.66520721, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:57:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 30.58s\n", + "\u001b[32m2025-05-30 10:57:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:58:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 93 (stopped at 108 epochs).\n", + "\u001b[32m2025-05-30 10:58:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/109 - loss=1.92888, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.078874007, MSE_maskV_-1.0=1.9282826, val_loss=1.0631583, val_CC_maskV_-1.0=0.16427077, val_MSE_maskV_-1.0=1.0573963, learning_rate=0.001\n", + "Epoch 12/109 - loss=0.77216321, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47550178, MSE_maskV_-1.0=0.77186501, val_loss=0.79143924, val_CC_maskV_-1.0=0.45985836, val_MSE_maskV_-1.0=0.78897125, learning_rate=0.001\n", + "Epoch 23/109 - loss=0.71346658, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53357327, MSE_maskV_-1.0=0.71347272, val_loss=0.73392284, val_CC_maskV_-1.0=0.51489836, val_MSE_maskV_-1.0=0.73293662, learning_rate=0.001\n", + "Epoch 34/109 - loss=0.67793834, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56524521, MSE_maskV_-1.0=0.67910081, val_loss=0.70102078, val_CC_maskV_-1.0=0.54471314, val_MSE_maskV_-1.0=0.69984114, learning_rate=0.001\n", + "Epoch 45/109 - loss=0.66047072, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58030349, MSE_maskV_-1.0=0.66003805, val_loss=0.68824172, val_CC_maskV_-1.0=0.55675679, val_MSE_maskV_-1.0=0.68745714, learning_rate=0.001\n", + "Epoch 56/109 - loss=0.64901513, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59048176, MSE_maskV_-1.0=0.64918619, val_loss=0.68051016, val_CC_maskV_-1.0=0.56330538, val_MSE_maskV_-1.0=0.67962611, learning_rate=0.001\n", + "Epoch 67/109 - loss=0.64138025, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59586734, MSE_maskV_-1.0=0.64113885, val_loss=0.67925745, val_CC_maskV_-1.0=0.56472027, val_MSE_maskV_-1.0=0.67868441, learning_rate=0.001\n", + "Epoch 78/109 - loss=0.63653237, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59954059, MSE_maskV_-1.0=0.63627201, val_loss=0.67326778, val_CC_maskV_-1.0=0.56914252, val_MSE_maskV_-1.0=0.67277753, learning_rate=0.001\n", + "Epoch 89/109 - loss=0.6310401, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60515308, MSE_maskV_-1.0=0.63166887, val_loss=0.67504352, val_CC_maskV_-1.0=0.56846917, val_MSE_maskV_-1.0=0.67474961, learning_rate=0.001\n", + "Epoch 100/109 - loss=0.62907046, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60635662, MSE_maskV_-1.0=0.62865382, val_loss=0.67325372, val_CC_maskV_-1.0=0.57068753, val_MSE_maskV_-1.0=0.67273879, learning_rate=0.001\n", + "Epoch 109/109 - loss=0.62624383, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60877782, MSE_maskV_-1.0=0.62602621, val_loss=0.66890973, val_CC_maskV_-1.0=0.57465869, val_MSE_maskV_-1.0=0.66819203, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:58:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 29.34s\n", + "\u001b[32m2025-05-30 10:58:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.66391236)\n", + "\u001b[32m2025-05-30 10:58:17\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 797us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:58:17\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.621, R2_maskV_-1.0=0.38, CC_maskV_-1.0=0.616\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 824us/step\n", + "51/51 [==============================] - 0s 765us/step\n", + "84/84 [==============================] - 0s 751us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 10:58:18\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_CzCy1HL64U_ErSV16\" (11/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_CzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 10:58:18\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_uAKCz1HL64U_ErSV16\" (12/16)\n", + "\u001b[32m2025-05-30 10:58:18\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 10:58:18\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 10:58:18\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 10:58:18\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 10:58:18\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 10:58:18\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 10:58:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:58:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 199 (stopped at 214 epochs).\n", + "\u001b[32m2025-05-30 10:58:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/215 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.99940497, rnn_1step_R2_maskV_-1.0=-0.022326637, rnn_1step_CC_maskV_-1.0=0.067580327, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96544981, val_rnn_1step_R2_maskV_-1.0=-0.08825849, val_rnn_1step_CC_maskV_-1.0=0.33914399, learning_rate=0.001\n", + "Epoch 23/215 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.63659996, rnn_1step_R2_maskV_-1.0=0.33687842, rnn_1step_CC_maskV_-1.0=0.60142487, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.69787651, val_rnn_1step_R2_maskV_-1.0=0.20253605, val_rnn_1step_CC_maskV_-1.0=0.53227413, learning_rate=0.001\n", + "Epoch 45/215 - loss=rnn_1step_loss=0.51766181, rnn_1step_R2_maskV_-1.0=0.4593235, rnn_1step_CC_maskV_-1.0=0.69350111, rnn_1step_MSE_maskV_-1.0=0.51766187, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.66308272, val_rnn_1step_R2_maskV_-1.0=0.24582794, val_rnn_1step_CC_maskV_-1.0=0.56891656, learning_rate=0.001\n", + "Epoch 67/215 - loss=rnn_1step_loss=0.39074603, rnn_1step_R2_maskV_-1.0=0.59410083, rnn_1step_CC_maskV_-1.0=0.77937496, rnn_1step_MSE_maskV_-1.0=0.39074606, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57771212, val_rnn_1step_R2_maskV_-1.0=0.33991355, val_rnn_1step_CC_maskV_-1.0=0.65001529, learning_rate=0.001\n", + "Epoch 89/215 - loss=rnn_1step_loss=0.32633045, rnn_1step_R2_maskV_-1.0=0.66045696, rnn_1step_CC_maskV_-1.0=0.82145727, rnn_1step_MSE_maskV_-1.0=0.32633048, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50700653, val_rnn_1step_R2_maskV_-1.0=0.42211208, val_rnn_1step_CC_maskV_-1.0=0.6918295, learning_rate=0.001\n", + "Epoch 111/215 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27613688, rnn_1step_R2_maskV_-1.0=0.71332955, rnn_1step_CC_maskV_-1.0=0.85021847, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49666134, val_rnn_1step_R2_maskV_-1.0=0.43346235, val_rnn_1step_CC_maskV_-1.0=0.70291084, learning_rate=0.001\n", + "Epoch 133/215 - loss=rnn_1step_loss=0.23902877, rnn_1step_R2_maskV_-1.0=0.75227016, rnn_1step_CC_maskV_-1.0=0.87145054, rnn_1step_MSE_maskV_-1.0=0.23902878, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48935637, val_rnn_1step_R2_maskV_-1.0=0.44187075, val_rnn_1step_CC_maskV_-1.0=0.71035278, learning_rate=0.001\n", + "Epoch 155/215 - loss=rnn_1step_loss=0.2189769, rnn_1step_R2_maskV_-1.0=0.77330619, rnn_1step_CC_maskV_-1.0=0.88271958, rnn_1step_MSE_maskV_-1.0=0.21897689, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48810041, val_rnn_1step_R2_maskV_-1.0=0.44266981, val_rnn_1step_CC_maskV_-1.0=0.7157169, learning_rate=0.001\n", + "Epoch 177/215 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.2054289, rnn_1step_R2_maskV_-1.0=0.78753901, rnn_1step_CC_maskV_-1.0=0.89047843, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48645949, val_rnn_1step_R2_maskV_-1.0=0.44400176, val_rnn_1step_CC_maskV_-1.0=0.71569532, learning_rate=0.001\n", + "Epoch 199/215 - loss=rnn_1step_loss=0.19287503, rnn_1step_R2_maskV_-1.0=0.80050075, rnn_1step_CC_maskV_-1.0=0.89834327, rnn_1step_MSE_maskV_-1.0=0.19287504, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46733078, val_rnn_1step_R2_maskV_-1.0=0.46772873, val_rnn_1step_CC_maskV_-1.0=0.72351146, learning_rate=0.001\n", + "Epoch 215/215 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.18860149, rnn_1step_R2_maskV_-1.0=0.80494088, rnn_1step_CC_maskV_-1.0=0.90031719, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49027714, val_rnn_1step_R2_maskV_-1.0=0.43975541, val_rnn_1step_CC_maskV_-1.0=0.71626365, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:58:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 24.58s\n", + "\u001b[32m2025-05-30 10:58:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 10:58:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 84 (stopped at 99 epochs).\n", + "\u001b[32m2025-05-30 10:58:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/100 - loss=rnn_1_1step_loss=0.9994294, rnn_1_1step_R2_maskV_-1.0=-0.022355951, rnn_1_1step_CC_maskV_-1.0=0.034843862, rnn_1_1step_MSE_maskV_-1.0=0.99942935, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96534616, val_rnn_1_1step_R2_maskV_-1.0=-0.088111252, val_rnn_1_1step_CC_maskV_-1.0=0.30056462, learning_rate=0.001\n", + "Epoch 11/100 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.87145072, rnn_1_1step_R2_maskV_-1.0=0.1046974, rnn_1_1step_CC_maskV_-1.0=0.36498991, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.81900984, val_rnn_1_1step_R2_maskV_-1.0=0.068277672, val_rnn_1_1step_CC_maskV_-1.0=0.39098644, learning_rate=0.001\n", + "Epoch 21/100 - loss=rnn_1_1step_loss=0.67087603, rnn_1_1step_R2_maskV_-1.0=0.30544126, rnn_1_1step_CC_maskV_-1.0=0.57950985, rnn_1_1step_MSE_maskV_-1.0=0.67087597, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.69333863, val_rnn_1_1step_R2_maskV_-1.0=0.20822506, val_rnn_1_1step_CC_maskV_-1.0=0.52707934, learning_rate=0.001\n", + "Epoch 31/100 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.54782355, rnn_1_1step_R2_maskV_-1.0=0.43000859, rnn_1_1step_CC_maskV_-1.0=0.67266965, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62958938, val_rnn_1_1step_R2_maskV_-1.0=0.27911747, val_rnn_1_1step_CC_maskV_-1.0=0.59820485, learning_rate=0.001\n", + "Epoch 41/100 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.47445381, rnn_1_1step_R2_maskV_-1.0=0.50602007, rnn_1_1step_CC_maskV_-1.0=0.72383875, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57756573, val_rnn_1_1step_R2_maskV_-1.0=0.3390519, val_rnn_1_1step_CC_maskV_-1.0=0.6349107, learning_rate=0.001\n", + "Epoch 51/100 - loss=rnn_1_1step_loss=0.41770515, rnn_1_1step_R2_maskV_-1.0=0.56569988, rnn_1_1step_CC_maskV_-1.0=0.76298928, rnn_1_1step_MSE_maskV_-1.0=0.41770512, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54564077, val_rnn_1_1step_R2_maskV_-1.0=0.37505546, val_rnn_1_1step_CC_maskV_-1.0=0.66035998, learning_rate=0.001\n", + "Epoch 61/100 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38137802, rnn_1_1step_R2_maskV_-1.0=0.60340834, rnn_1_1step_CC_maskV_-1.0=0.78553319, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54699033, val_rnn_1_1step_R2_maskV_-1.0=0.37270373, val_rnn_1_1step_CC_maskV_-1.0=0.66503668, learning_rate=0.001\n", + "Epoch 71/100 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.35785568, rnn_1_1step_R2_maskV_-1.0=0.62759769, rnn_1_1step_CC_maskV_-1.0=0.79987669, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5386675, val_rnn_1_1step_R2_maskV_-1.0=0.38288155, val_rnn_1_1step_CC_maskV_-1.0=0.6686818, learning_rate=0.001\n", + "Epoch 81/100 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33107576, rnn_1_1step_R2_maskV_-1.0=0.65549541, rnn_1_1step_CC_maskV_-1.0=0.81685233, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54880285, val_rnn_1_1step_R2_maskV_-1.0=0.37020877, val_rnn_1_1step_CC_maskV_-1.0=0.66869867, learning_rate=0.001\n", + "Epoch 91/100 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30914313, rnn_1_1step_R2_maskV_-1.0=0.67838252, rnn_1_1step_CC_maskV_-1.0=0.8311891, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53731424, val_rnn_1_1step_R2_maskV_-1.0=0.3842836, val_rnn_1_1step_CC_maskV_-1.0=0.67632085, learning_rate=0.001\n", + "Epoch 100/100 - loss=rnn_1_1step_loss=0.29060605, rnn_1_1step_R2_maskV_-1.0=0.6977129, rnn_1_1step_CC_maskV_-1.0=0.84169495, rnn_1_1step_MSE_maskV_-1.0=0.29060608, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53106576, val_rnn_1_1step_R2_maskV_-1.0=0.39258176, val_rnn_1_1step_CC_maskV_-1.0=0.67897773, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:58:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 13.41s\n", + "\u001b[32m2025-05-30 10:58:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.46733078)\n", + "\u001b[32m2025-05-30 10:58:58\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.181, R2_maskV_-1.0=0.819, CC_maskV_-1.0=0.906\n", + "\u001b[32m2025-05-30 10:58:58\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.418, R2_maskV_-1.0=0.536, CC_maskV_-1.0=0.758\n", + "\u001b[32m2025-05-30 10:58:58\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 10:58:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 10:59:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 221 (stopped at 236 epochs).\n", + "\u001b[32m2025-05-30 10:59:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/237 - loss=2.0995159, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.016614912, MSE_maskV_-1.0=2.098716, val_loss=1.1152006, val_CC_maskV_-1.0=0.07001964, val_MSE_maskV_-1.0=1.1119226, learning_rate=0.001\n", + "Epoch 25/237 - loss=0.87501174, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35599631, MSE_maskV_-1.0=0.87616307, val_loss=0.88351125, val_CC_maskV_-1.0=0.35986859, val_MSE_maskV_-1.0=0.88038248, learning_rate=0.001\n", + "Epoch 49/237 - loss=0.85358441, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38501173, MSE_maskV_-1.0=0.85339487, val_loss=0.86438859, val_CC_maskV_-1.0=0.3860499, val_MSE_maskV_-1.0=0.86174357, learning_rate=0.001\n", + "Epoch 73/237 - loss=0.84208411, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39992967, MSE_maskV_-1.0=0.84164453, val_loss=0.85508078, val_CC_maskV_-1.0=0.39740059, val_MSE_maskV_-1.0=0.85236806, learning_rate=0.001\n", + "Epoch 97/237 - loss=0.83445704, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40897831, MSE_maskV_-1.0=0.83350134, val_loss=0.84867418, val_CC_maskV_-1.0=0.406169, val_MSE_maskV_-1.0=0.84606636, learning_rate=0.001\n", + "Epoch 121/237 - loss=0.82887238, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41633743, MSE_maskV_-1.0=0.82873362, val_loss=0.84246886, val_CC_maskV_-1.0=0.41264051, val_MSE_maskV_-1.0=0.83956355, learning_rate=0.001\n", + "Epoch 145/237 - loss=0.8252477, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4195486, MSE_maskV_-1.0=0.82548875, val_loss=0.84025258, val_CC_maskV_-1.0=0.41430193, val_MSE_maskV_-1.0=0.83738714, learning_rate=0.001\n", + "Epoch 169/237 - loss=0.82177216, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42407188, MSE_maskV_-1.0=0.82173127, val_loss=0.83683515, val_CC_maskV_-1.0=0.41825062, val_MSE_maskV_-1.0=0.83410639, learning_rate=0.001\n", + "Epoch 193/237 - loss=0.81936014, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42666802, MSE_maskV_-1.0=0.81862259, val_loss=0.83507127, val_CC_maskV_-1.0=0.42055815, val_MSE_maskV_-1.0=0.83233005, learning_rate=0.001\n", + "Epoch 217/237 - loss=0.81733507, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42919147, MSE_maskV_-1.0=0.81674832, val_loss=0.8329038, val_CC_maskV_-1.0=0.42319345, val_MSE_maskV_-1.0=0.8302936, learning_rate=0.001\n", + "Epoch 237/237 - loss=0.81576943, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43057525, MSE_maskV_-1.0=0.81538033, val_loss=0.83195436, val_CC_maskV_-1.0=0.42342597, val_MSE_maskV_-1.0=0.82916695, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 10:59:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 58.11s\n", + "\u001b[32m2025-05-30 10:59:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:00:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 221 (stopped at 236 epochs).\n", + "\u001b[32m2025-05-30 11:00:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/237 - loss=1.9625092, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.015880976, MSE_maskV_-1.0=1.9622364, val_loss=1.1353793, val_CC_maskV_-1.0=0.062454909, val_MSE_maskV_-1.0=1.1331224, learning_rate=0.001\n", + "Epoch 25/237 - loss=0.8754164, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35526812, MSE_maskV_-1.0=0.87658781, val_loss=0.88500971, val_CC_maskV_-1.0=0.3568874, val_MSE_maskV_-1.0=0.88227928, learning_rate=0.001\n", + "Epoch 49/237 - loss=0.85447717, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38372284, MSE_maskV_-1.0=0.85429043, val_loss=0.86594957, val_CC_maskV_-1.0=0.38331431, val_MSE_maskV_-1.0=0.86360353, learning_rate=0.001\n", + "Epoch 73/237 - loss=0.84285372, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39893803, MSE_maskV_-1.0=0.84241951, val_loss=0.85659981, val_CC_maskV_-1.0=0.39480919, val_MSE_maskV_-1.0=0.85420996, learning_rate=0.001\n", + "Epoch 97/237 - loss=0.83510906, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40816635, MSE_maskV_-1.0=0.83415037, val_loss=0.84988171, val_CC_maskV_-1.0=0.4041748, val_MSE_maskV_-1.0=0.84753436, learning_rate=0.001\n", + "Epoch 121/237 - loss=0.82937604, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41574439, MSE_maskV_-1.0=0.82924592, val_loss=0.84362042, val_CC_maskV_-1.0=0.41084471, val_MSE_maskV_-1.0=0.8409338, learning_rate=0.001\n", + "Epoch 145/237 - loss=0.82564628, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41910926, MSE_maskV_-1.0=0.82587385, val_loss=0.84091407, val_CC_maskV_-1.0=0.41309786, val_MSE_maskV_-1.0=0.83831823, learning_rate=0.001\n", + "Epoch 169/237 - loss=0.82209074, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4236927, MSE_maskV_-1.0=0.82207561, val_loss=0.83737689, val_CC_maskV_-1.0=0.41724721, val_MSE_maskV_-1.0=0.83492154, learning_rate=0.001\n", + "Epoch 193/237 - loss=0.81962264, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42638177, MSE_maskV_-1.0=0.81888151, val_loss=0.83555651, val_CC_maskV_-1.0=0.41961229, val_MSE_maskV_-1.0=0.83309293, learning_rate=0.001\n", + "Epoch 217/237 - loss=0.8175326, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42896131, MSE_maskV_-1.0=0.81694347, val_loss=0.833354, val_CC_maskV_-1.0=0.42235535, val_MSE_maskV_-1.0=0.83098221, learning_rate=0.001\n", + "Epoch 237/237 - loss=0.81594098, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43039402, MSE_maskV_-1.0=0.81554157, val_loss=0.83233821, val_CC_maskV_-1.0=0.42270249, val_MSE_maskV_-1.0=0.82976556, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:00:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 56.73s\n", + "\u001b[32m2025-05-30 11:00:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.82981563)\n", + "\u001b[32m2025-05-30 11:00:53\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 706us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:00:53\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.815, R2_maskV_-1.0=0.185, CC_maskV_-1.0=0.431\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 740us/step\n", + "51/51 [==============================] - 0s 781us/step\n", + "84/84 [==============================] - 0s 711us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:00:54\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_uAKCz1HL64U_ErSV16\" (12/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_uAKCz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:00:54\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_uAKCy1HL64U_ErSV16\" (13/16)\n", + "\u001b[32m2025-05-30 11:00:54\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:00:54\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:00:54\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:00:54\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:00:54\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:00:54\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:00:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:01:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 59 (stopped at 74 epochs).\n", + "\u001b[32m2025-05-30 11:01:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/75 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.99908781, rnn_1step_R2_maskV_-1.0=-0.022000674, rnn_1step_CC_maskV_-1.0=0.046629462, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96462232, val_rnn_1step_R2_maskV_-1.0=-0.087313563, val_rnn_1step_CC_maskV_-1.0=0.28055683, learning_rate=0.001\n", + "Epoch 9/75 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.92428613, rnn_1step_R2_maskV_-1.0=0.053813323, rnn_1step_CC_maskV_-1.0=0.39792308, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.87398535, val_rnn_1step_R2_maskV_-1.0=0.012221277, val_rnn_1step_CC_maskV_-1.0=0.40078479, learning_rate=0.001\n", + "Epoch 17/75 - loss=rnn_1step_loss=0.69509393, rnn_1step_R2_maskV_-1.0=0.28506917, rnn_1step_CC_maskV_-1.0=0.55719173, rnn_1step_MSE_maskV_-1.0=0.69509399, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.69972062, val_rnn_1step_R2_maskV_-1.0=0.2024297, val_rnn_1step_CC_maskV_-1.0=0.52978265, learning_rate=0.001\n", + "Epoch 25/75 - loss=rnn_1step_loss=0.54840344, rnn_1step_R2_maskV_-1.0=0.43190628, rnn_1step_CC_maskV_-1.0=0.67389399, rnn_1step_MSE_maskV_-1.0=0.54840338, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59276992, val_rnn_1step_R2_maskV_-1.0=0.32076937, val_rnn_1step_CC_maskV_-1.0=0.62031281, learning_rate=0.001\n", + "Epoch 33/75 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.45677042, rnn_1step_R2_maskV_-1.0=0.52575994, rnn_1step_CC_maskV_-1.0=0.73699647, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55939704, val_rnn_1step_R2_maskV_-1.0=0.35783976, val_rnn_1step_CC_maskV_-1.0=0.65482068, learning_rate=0.001\n", + "Epoch 41/75 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38975725, rnn_1step_R2_maskV_-1.0=0.59500134, rnn_1step_CC_maskV_-1.0=0.78134227, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54005361, val_rnn_1step_R2_maskV_-1.0=0.37974596, val_rnn_1step_CC_maskV_-1.0=0.67235392, learning_rate=0.001\n", + "Epoch 49/75 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32918367, rnn_1step_R2_maskV_-1.0=0.65849113, rnn_1step_CC_maskV_-1.0=0.81844938, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51447719, val_rnn_1step_R2_maskV_-1.0=0.41111785, val_rnn_1step_CC_maskV_-1.0=0.69360107, learning_rate=0.001\n", + "Epoch 57/75 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.28856173, rnn_1step_R2_maskV_-1.0=0.70174962, rnn_1step_CC_maskV_-1.0=0.84257424, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5237568, val_rnn_1step_R2_maskV_-1.0=0.39941859, val_rnn_1step_CC_maskV_-1.0=0.69161689, learning_rate=0.001\n", + "Epoch 65/75 - loss=rnn_1step_loss=0.26753542, rnn_1step_R2_maskV_-1.0=0.72373605, rnn_1step_CC_maskV_-1.0=0.85499334, rnn_1step_MSE_maskV_-1.0=0.26753539, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51975137, val_rnn_1step_R2_maskV_-1.0=0.40437931, val_rnn_1step_CC_maskV_-1.0=0.69593358, learning_rate=0.001\n", + "Epoch 73/75 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.25074148, rnn_1step_R2_maskV_-1.0=0.74106532, rnn_1step_CC_maskV_-1.0=0.86462247, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5300976, val_rnn_1step_R2_maskV_-1.0=0.39214063, val_rnn_1step_CC_maskV_-1.0=0.69124395, learning_rate=0.001\n", + "Epoch 75/75 - loss=rnn_1step_loss=0.24738884, rnn_1step_R2_maskV_-1.0=0.74445444, rnn_1step_CC_maskV_-1.0=0.86671847, rnn_1step_MSE_maskV_-1.0=0.24738885, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5282076, val_rnn_1step_R2_maskV_-1.0=0.39417544, val_rnn_1step_CC_maskV_-1.0=0.69352752, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:01:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.16s\n", + "\u001b[32m2025-05-30 11:01:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:01:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 71 (stopped at 86 epochs).\n", + "\u001b[32m2025-05-30 11:01:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/87 - loss=rnn_1_1step_loss=0.99866802, rnn_1_1step_R2_maskV_-1.0=-0.021572087, rnn_1_1step_CC_maskV_-1.0=0.10694696, rnn_1_1step_MSE_maskV_-1.0=0.99866796, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96391934, val_rnn_1_1step_R2_maskV_-1.0=-0.086571068, val_rnn_1_1step_CC_maskV_-1.0=0.31185135, learning_rate=0.001\n", + "Epoch 10/87 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.86546779, rnn_1_1step_R2_maskV_-1.0=0.11257887, rnn_1_1step_CC_maskV_-1.0=0.38056654, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.81738585, val_rnn_1_1step_R2_maskV_-1.0=0.070302486, val_rnn_1_1step_CC_maskV_-1.0=0.39858434, learning_rate=0.001\n", + "Epoch 19/87 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.72715658, rnn_1_1step_R2_maskV_-1.0=0.25242966, rnn_1_1step_CC_maskV_-1.0=0.52625406, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.72771072, val_rnn_1_1step_R2_maskV_-1.0=0.1711551, val_rnn_1_1step_CC_maskV_-1.0=0.49613148, learning_rate=0.001\n", + "Epoch 28/87 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.57295489, rnn_1_1step_R2_maskV_-1.0=0.40734673, rnn_1_1step_CC_maskV_-1.0=0.65893555, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61802524, val_rnn_1_1step_R2_maskV_-1.0=0.29394287, val_rnn_1_1step_CC_maskV_-1.0=0.60202801, learning_rate=0.001\n", + "Epoch 37/87 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44445977, rnn_1_1step_R2_maskV_-1.0=0.53732121, rnn_1_1step_CC_maskV_-1.0=0.74610919, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56114763, val_rnn_1_1step_R2_maskV_-1.0=0.36093736, val_rnn_1_1step_CC_maskV_-1.0=0.65541095, learning_rate=0.001\n", + "Epoch 46/87 - loss=rnn_1_1step_loss=0.38468036, rnn_1_1step_R2_maskV_-1.0=0.59930909, rnn_1_1step_CC_maskV_-1.0=0.78463131, rnn_1_1step_MSE_maskV_-1.0=0.38468033, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5445767, val_rnn_1_1step_R2_maskV_-1.0=0.37866926, val_rnn_1_1step_CC_maskV_-1.0=0.67293787, learning_rate=0.001\n", + "Epoch 55/87 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.34129003, rnn_1_1step_R2_maskV_-1.0=0.64472818, rnn_1_1step_CC_maskV_-1.0=0.81218255, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53313965, val_rnn_1_1step_R2_maskV_-1.0=0.39130169, val_rnn_1_1step_CC_maskV_-1.0=0.6824469, learning_rate=0.001\n", + "Epoch 64/87 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.2987372, rnn_1_1step_R2_maskV_-1.0=0.68974274, rnn_1_1step_CC_maskV_-1.0=0.83720863, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52284217, val_rnn_1_1step_R2_maskV_-1.0=0.40352985, val_rnn_1_1step_CC_maskV_-1.0=0.68996781, learning_rate=0.001\n", + "Epoch 73/87 - loss=rnn_1_1step_loss=0.27727035, rnn_1_1step_R2_maskV_-1.0=0.71252847, rnn_1_1step_CC_maskV_-1.0=0.84987581, rnn_1_1step_MSE_maskV_-1.0=0.27727038, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52169967, val_rnn_1_1step_R2_maskV_-1.0=0.40496716, val_rnn_1_1step_CC_maskV_-1.0=0.69225663, learning_rate=0.001\n", + "Epoch 82/87 - loss=rnn_1_1step_loss=0.26692995, rnn_1_1step_R2_maskV_-1.0=0.72337711, rnn_1_1step_CC_maskV_-1.0=0.85507095, rnn_1_1step_MSE_maskV_-1.0=0.26692998, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53075218, val_rnn_1_1step_R2_maskV_-1.0=0.39373076, val_rnn_1_1step_CC_maskV_-1.0=0.68666661, learning_rate=0.001\n", + "Epoch 87/87 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.2674253, rnn_1_1step_R2_maskV_-1.0=0.72257853, rnn_1_1step_CC_maskV_-1.0=0.85477656, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53145653, val_rnn_1_1step_R2_maskV_-1.0=0.39312589, val_rnn_1_1step_CC_maskV_-1.0=0.68870538, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:01:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 11.31s\n", + "\u001b[32m2025-05-30 11:01:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.50443286)\n", + "\u001b[32m2025-05-30 11:01:17\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.256, R2_maskV_-1.0=0.744, CC_maskV_-1.0=0.863\n", + "\u001b[32m2025-05-30 11:01:18\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.47, R2_maskV_-1.0=0.479, CC_maskV_-1.0=0.728\n", + "\u001b[32m2025-05-30 11:01:18\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:01:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:02:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 180 (stopped at 195 epochs).\n", + "\u001b[32m2025-05-30 11:02:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/196 - loss=1.0267311, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.16463679, MSE_maskV_-1.0=1.0285321, val_loss=0.94894743, val_CC_maskV_-1.0=0.24118865, val_MSE_maskV_-1.0=0.94636947, learning_rate=0.001\n", + "Epoch 21/196 - loss=0.81986839, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42613092, MSE_maskV_-1.0=0.81966507, val_loss=0.85312086, val_CC_maskV_-1.0=0.39453918, val_MSE_maskV_-1.0=0.85103011, learning_rate=0.001\n", + "Epoch 41/196 - loss=0.788257, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46075809, MSE_maskV_-1.0=0.78853625, val_loss=0.82792538, val_CC_maskV_-1.0=0.42135254, val_MSE_maskV_-1.0=0.82664412, learning_rate=0.001\n", + "Epoch 61/196 - loss=0.77203357, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47783509, MSE_maskV_-1.0=0.77149624, val_loss=0.81301385, val_CC_maskV_-1.0=0.43844402, val_MSE_maskV_-1.0=0.81078476, learning_rate=0.001\n", + "Epoch 81/196 - loss=0.7603395, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48990867, MSE_maskV_-1.0=0.76039934, val_loss=0.80399877, val_CC_maskV_-1.0=0.44594458, val_MSE_maskV_-1.0=0.80292082, learning_rate=0.001\n", + "Epoch 101/196 - loss=0.75285959, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49733293, MSE_maskV_-1.0=0.75268751, val_loss=0.79940373, val_CC_maskV_-1.0=0.45197177, val_MSE_maskV_-1.0=0.79730898, learning_rate=0.001\n", + "Epoch 121/196 - loss=0.74573159, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50395966, MSE_maskV_-1.0=0.74555838, val_loss=0.79578352, val_CC_maskV_-1.0=0.45474786, val_MSE_maskV_-1.0=0.79438847, learning_rate=0.001\n", + "Epoch 141/196 - loss=0.74025595, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50874668, MSE_maskV_-1.0=0.74382955, val_loss=0.78868365, val_CC_maskV_-1.0=0.46116486, val_MSE_maskV_-1.0=0.78742886, learning_rate=0.001\n", + "Epoch 161/196 - loss=0.73543906, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51343775, MSE_maskV_-1.0=0.73557073, val_loss=0.79299778, val_CC_maskV_-1.0=0.45745134, val_MSE_maskV_-1.0=0.79217041, learning_rate=0.001\n", + "Epoch 181/196 - loss=0.73184782, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51662427, MSE_maskV_-1.0=0.73176849, val_loss=0.78490943, val_CC_maskV_-1.0=0.46340925, val_MSE_maskV_-1.0=0.78416336, learning_rate=0.001\n", + "Epoch 196/196 - loss=0.72989529, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51797962, MSE_maskV_-1.0=0.72909606, val_loss=0.78167254, val_CC_maskV_-1.0=0.46658662, val_MSE_maskV_-1.0=0.78141433, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:02:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 50.85s\n", + "\u001b[32m2025-05-30 11:02:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:03:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 231 (stopped at 246 epochs).\n", + "\u001b[32m2025-05-30 11:03:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/247 - loss=1.0110296, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.17836984, MSE_maskV_-1.0=1.0128689, val_loss=0.94536626, val_CC_maskV_-1.0=0.24844651, val_MSE_maskV_-1.0=0.94393927, learning_rate=0.001\n", + "Epoch 26/247 - loss=0.80775857, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44022253, MSE_maskV_-1.0=0.80727649, val_loss=0.84184241, val_CC_maskV_-1.0=0.40623865, val_MSE_maskV_-1.0=0.84020507, learning_rate=0.001\n", + "Epoch 51/247 - loss=0.77779949, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47146302, MSE_maskV_-1.0=0.77729529, val_loss=0.81594563, val_CC_maskV_-1.0=0.43301818, val_MSE_maskV_-1.0=0.81454563, learning_rate=0.001\n", + "Epoch 76/247 - loss=0.76190025, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48788691, MSE_maskV_-1.0=0.76166946, val_loss=0.8047545, val_CC_maskV_-1.0=0.44470844, val_MSE_maskV_-1.0=0.80379754, learning_rate=0.001\n", + "Epoch 101/247 - loss=0.75087482, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49924904, MSE_maskV_-1.0=0.75065607, val_loss=0.79814696, val_CC_maskV_-1.0=0.4525581, val_MSE_maskV_-1.0=0.79633772, learning_rate=0.001\n", + "Epoch 126/247 - loss=0.74193561, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50739115, MSE_maskV_-1.0=0.74130267, val_loss=0.78970999, val_CC_maskV_-1.0=0.45962563, val_MSE_maskV_-1.0=0.78871953, learning_rate=0.001\n", + "Epoch 151/247 - loss=0.73679221, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51221132, MSE_maskV_-1.0=0.73646247, val_loss=0.78593373, val_CC_maskV_-1.0=0.46438816, val_MSE_maskV_-1.0=0.78434336, learning_rate=0.001\n", + "Epoch 176/247 - loss=0.73034382, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51778662, MSE_maskV_-1.0=0.72989315, val_loss=0.78698975, val_CC_maskV_-1.0=0.46402138, val_MSE_maskV_-1.0=0.78571093, learning_rate=0.001\n", + "Epoch 201/247 - loss=0.72550815, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52269971, MSE_maskV_-1.0=0.72521728, val_loss=0.78019297, val_CC_maskV_-1.0=0.46973008, val_MSE_maskV_-1.0=0.77866185, learning_rate=0.001\n", + "Epoch 226/247 - loss=0.72186393, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52612865, MSE_maskV_-1.0=0.72165197, val_loss=0.77788144, val_CC_maskV_-1.0=0.47307467, val_MSE_maskV_-1.0=0.77589059, learning_rate=0.001\n", + "Epoch 247/247 - loss=0.71900523, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52863371, MSE_maskV_-1.0=0.7192452, val_loss=0.77422571, val_CC_maskV_-1.0=0.47680792, val_MSE_maskV_-1.0=0.77227545, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:03:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 63.91s\n", + "\u001b[32m2025-05-30 11:03:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.77277279)\n", + "\u001b[32m2025-05-30 11:03:12\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 821us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:03:13\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.716, R2_maskV_-1.0=0.285, CC_maskV_-1.0=0.533\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 899us/step\n", + "51/51 [==============================] - 0s 761us/step\n", + "84/84 [==============================] - 0s 765us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:03:13\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_uAKCy1HL64U_ErSV16\" (13/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_uAKCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:03:13\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_ACzCy1HL64U_ErSV16\" (14/16)\n", + "\u001b[32m2025-05-30 11:03:13\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:03:13\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:03:13\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:03:14\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:03:14\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:03:14\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:03:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:03:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 174 (stopped at 189 epochs).\n", + "\u001b[32m2025-05-30 11:03:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/190 - loss=rnn_1step_loss=0.99916172, rnn_1step_R2_maskV_-1.0=-0.022079639, rnn_1step_CC_maskV_-1.0=0.040701501, rnn_1step_MSE_maskV_-1.0=0.99916166, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96479923, val_rnn_1step_R2_maskV_-1.0=-0.087584063, val_rnn_1step_CC_maskV_-1.0=0.23777488, learning_rate=0.001\n", + "Epoch 20/190 - loss=rnn_1step_loss=0.68921232, rnn_1step_R2_maskV_-1.0=0.28666022, rnn_1step_CC_maskV_-1.0=0.55662215, rnn_1step_MSE_maskV_-1.0=0.68921226, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.72452837, val_rnn_1step_R2_maskV_-1.0=0.17182221, val_rnn_1step_CC_maskV_-1.0=0.51246506, learning_rate=0.001\n", + "Epoch 39/190 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.50340772, rnn_1step_R2_maskV_-1.0=0.47850263, rnn_1step_CC_maskV_-1.0=0.70370388, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59531659, val_rnn_1step_R2_maskV_-1.0=0.32044217, val_rnn_1step_CC_maskV_-1.0=0.62302297, learning_rate=0.001\n", + "Epoch 58/190 - loss=rnn_1step_loss=0.45366585, rnn_1step_R2_maskV_-1.0=0.5297482, rnn_1step_CC_maskV_-1.0=0.73801422, rnn_1step_MSE_maskV_-1.0=0.45366582, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5630278, val_rnn_1step_R2_maskV_-1.0=0.35375136, val_rnn_1step_CC_maskV_-1.0=0.64460009, learning_rate=0.001\n", + "Epoch 77/190 - loss=rnn_1step_loss=0.41943753, rnn_1step_R2_maskV_-1.0=0.56545186, rnn_1step_CC_maskV_-1.0=0.76047206, rnn_1step_MSE_maskV_-1.0=0.41943756, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5617891, val_rnn_1step_R2_maskV_-1.0=0.35297811, val_rnn_1step_CC_maskV_-1.0=0.65249133, learning_rate=0.001\n", + "Epoch 96/190 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39038098, rnn_1step_R2_maskV_-1.0=0.59508938, rnn_1step_CC_maskV_-1.0=0.77950728, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54573256, val_rnn_1step_R2_maskV_-1.0=0.37021443, val_rnn_1step_CC_maskV_-1.0=0.67121512, learning_rate=0.001\n", + "Epoch 115/190 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.36340106, rnn_1step_R2_maskV_-1.0=0.62362254, rnn_1step_CC_maskV_-1.0=0.79652727, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5073176, val_rnn_1step_R2_maskV_-1.0=0.4157446, val_rnn_1step_CC_maskV_-1.0=0.69508308, learning_rate=0.001\n", + "Epoch 134/190 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.36277238, rnn_1step_R2_maskV_-1.0=0.62430727, rnn_1step_CC_maskV_-1.0=0.79776096, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51967901, val_rnn_1step_R2_maskV_-1.0=0.40208369, val_rnn_1step_CC_maskV_-1.0=0.69261605, learning_rate=0.001\n", + "Epoch 153/190 - loss=rnn_1step_loss=0.36024344, rnn_1step_R2_maskV_-1.0=0.62635404, rnn_1step_CC_maskV_-1.0=0.80010629, rnn_1step_MSE_maskV_-1.0=0.36024341, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48186889, val_rnn_1step_R2_maskV_-1.0=0.44762397, val_rnn_1step_CC_maskV_-1.0=0.70673203, learning_rate=0.001\n", + "Epoch 172/190 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33034131, rnn_1step_R2_maskV_-1.0=0.6576038, rnn_1step_CC_maskV_-1.0=0.81834865, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46930456, val_rnn_1step_R2_maskV_-1.0=0.46367139, val_rnn_1step_CC_maskV_-1.0=0.71564609, learning_rate=0.001\n", + "Epoch 190/190 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31862339, rnn_1step_R2_maskV_-1.0=0.67006874, rnn_1step_CC_maskV_-1.0=0.82507747, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49967432, val_rnn_1step_R2_maskV_-1.0=0.42758298, val_rnn_1step_CC_maskV_-1.0=0.70390862, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:03:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 21.64s\n", + "\u001b[32m2025-05-30 11:03:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:03:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 167 (stopped at 182 epochs).\n", + "\u001b[32m2025-05-30 11:03:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/183 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.99892831, rnn_1_1step_R2_maskV_-1.0=-0.021827355, rnn_1_1step_CC_maskV_-1.0=0.071672782, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.9643262, val_rnn_1_1step_R2_maskV_-1.0=-0.086942002, val_rnn_1_1step_CC_maskV_-1.0=0.24324016, learning_rate=0.001\n", + "Epoch 20/183 - loss=rnn_1_1step_loss=0.70084125, rnn_1_1step_R2_maskV_-1.0=0.27694377, rnn_1_1step_CC_maskV_-1.0=0.54620677, rnn_1_1step_MSE_maskV_-1.0=0.70084131, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.73456001, val_rnn_1_1step_R2_maskV_-1.0=0.16285962, val_rnn_1_1step_CC_maskV_-1.0=0.49422085, learning_rate=0.001\n", + "Epoch 39/183 - loss=rnn_1_1step_loss=0.53015941, rnn_1_1step_R2_maskV_-1.0=0.45221943, rnn_1_1step_CC_maskV_-1.0=0.68521172, rnn_1_1step_MSE_maskV_-1.0=0.53015935, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63723403, val_rnn_1_1step_R2_maskV_-1.0=0.27763695, val_rnn_1_1step_CC_maskV_-1.0=0.58520585, learning_rate=0.001\n", + "Epoch 58/183 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.4818379, rnn_1_1step_R2_maskV_-1.0=0.50312567, rnn_1_1step_CC_maskV_-1.0=0.71858889, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61379838, val_rnn_1_1step_R2_maskV_-1.0=0.30178201, val_rnn_1_1step_CC_maskV_-1.0=0.610551, learning_rate=0.001\n", + "Epoch 77/183 - loss=rnn_1_1step_loss=0.45240819, rnn_1_1step_R2_maskV_-1.0=0.5329318, rnn_1_1step_CC_maskV_-1.0=0.73931402, rnn_1_1step_MSE_maskV_-1.0=0.45240816, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59086341, val_rnn_1_1step_R2_maskV_-1.0=0.32639295, val_rnn_1_1step_CC_maskV_-1.0=0.62872481, learning_rate=0.001\n", + "Epoch 96/183 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.43046769, rnn_1_1step_R2_maskV_-1.0=0.55490583, rnn_1_1step_CC_maskV_-1.0=0.75348848, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57749146, val_rnn_1_1step_R2_maskV_-1.0=0.33851409, val_rnn_1_1step_CC_maskV_-1.0=0.64286715, learning_rate=0.001\n", + "Epoch 115/183 - loss=rnn_1_1step_loss=0.41873279, rnn_1_1step_R2_maskV_-1.0=0.56644785, rnn_1_1step_CC_maskV_-1.0=0.76343429, rnn_1_1step_MSE_maskV_-1.0=0.41873282, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54619032, val_rnn_1_1step_R2_maskV_-1.0=0.374733, val_rnn_1_1step_CC_maskV_-1.0=0.66272241, learning_rate=0.001\n", + "Epoch 134/183 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39944139, rnn_1_1step_R2_maskV_-1.0=0.58636081, rnn_1_1step_CC_maskV_-1.0=0.77682137, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5108673, val_rnn_1_1step_R2_maskV_-1.0=0.41548389, val_rnn_1_1step_CC_maskV_-1.0=0.68567294, learning_rate=0.001\n", + "Epoch 153/183 - loss=rnn_1_1step_loss=0.38328686, rnn_1_1step_R2_maskV_-1.0=0.6030283, rnn_1_1step_CC_maskV_-1.0=0.78595245, rnn_1_1step_MSE_maskV_-1.0=0.38328689, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51026446, val_rnn_1_1step_R2_maskV_-1.0=0.41589233, val_rnn_1_1step_CC_maskV_-1.0=0.69022816, learning_rate=0.001\n", + "Epoch 172/183 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.37116602, rnn_1_1step_R2_maskV_-1.0=0.6159234, rnn_1_1step_CC_maskV_-1.0=0.79223263, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50310928, val_rnn_1_1step_R2_maskV_-1.0=0.42220697, val_rnn_1_1step_CC_maskV_-1.0=0.6974144, learning_rate=0.001\n", + "Epoch 183/183 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.35184547, rnn_1_1step_R2_maskV_-1.0=0.63600743, rnn_1_1step_CC_maskV_-1.0=0.80437273, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50942421, val_rnn_1_1step_R2_maskV_-1.0=0.41349423, val_rnn_1_1step_CC_maskV_-1.0=0.69762141, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:03:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 21.62s\n", + "\u001b[32m2025-05-30 11:03:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.45779225)\n", + "\u001b[32m2025-05-30 11:03:59\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.316, R2_maskV_-1.0=0.684, CC_maskV_-1.0=0.829\n", + "\u001b[32m2025-05-30 11:03:59\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.445, R2_maskV_-1.0=0.503, CC_maskV_-1.0=0.738\n", + "\u001b[32m2025-05-30 11:03:59\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:03:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:04:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 187 (stopped at 202 epochs).\n", + "\u001b[32m2025-05-30 11:04:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/203 - loss=1.1399227, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.18220964, MSE_maskV_-1.0=1.1405194, val_loss=0.90460843, val_CC_maskV_-1.0=0.32136023, val_MSE_maskV_-1.0=0.90293592, learning_rate=0.001\n", + "Epoch 22/203 - loss=0.65569103, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58440071, MSE_maskV_-1.0=0.65578943, val_loss=0.6782589, val_CC_maskV_-1.0=0.56650281, val_MSE_maskV_-1.0=0.67640138, learning_rate=0.001\n", + "Epoch 43/203 - loss=0.62833637, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60702991, MSE_maskV_-1.0=0.62845385, val_loss=0.65852165, val_CC_maskV_-1.0=0.58346421, val_MSE_maskV_-1.0=0.65752202, learning_rate=0.001\n", + "Epoch 64/203 - loss=0.61712933, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61657894, MSE_maskV_-1.0=0.61705357, val_loss=0.64755344, val_CC_maskV_-1.0=0.59245342, val_MSE_maskV_-1.0=0.64604104, learning_rate=0.001\n", + "Epoch 85/203 - loss=0.6095404, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62196046, MSE_maskV_-1.0=0.60951042, val_loss=0.64345831, val_CC_maskV_-1.0=0.59553403, val_MSE_maskV_-1.0=0.6424318, learning_rate=0.001\n", + "Epoch 106/203 - loss=0.6039775, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62606955, MSE_maskV_-1.0=0.60346431, val_loss=0.6392529, val_CC_maskV_-1.0=0.59934229, val_MSE_maskV_-1.0=0.6377086, learning_rate=0.001\n", + "Epoch 127/203 - loss=0.59766656, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63032216, MSE_maskV_-1.0=0.59927005, val_loss=0.63519007, val_CC_maskV_-1.0=0.60205525, val_MSE_maskV_-1.0=0.63397622, learning_rate=0.001\n", + "Epoch 148/203 - loss=0.59362549, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63519353, MSE_maskV_-1.0=0.59455085, val_loss=0.62862605, val_CC_maskV_-1.0=0.60811549, val_MSE_maskV_-1.0=0.62725103, learning_rate=0.001\n", + "Epoch 169/203 - loss=0.58972347, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63754237, MSE_maskV_-1.0=0.58986223, val_loss=0.63171107, val_CC_maskV_-1.0=0.60597825, val_MSE_maskV_-1.0=0.63043559, learning_rate=0.001\n", + "Epoch 190/203 - loss=0.58810389, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63800597, MSE_maskV_-1.0=0.58810222, val_loss=0.62765652, val_CC_maskV_-1.0=0.60822392, val_MSE_maskV_-1.0=0.62611109, learning_rate=0.001\n", + "Epoch 203/203 - loss=0.58688933, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64058113, MSE_maskV_-1.0=0.58649814, val_loss=0.62848181, val_CC_maskV_-1.0=0.60862917, val_MSE_maskV_-1.0=0.62673539, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:04:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 52.92s\n", + "\u001b[32m2025-05-30 11:04:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:05:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 148 (stopped at 163 epochs).\n", + "\u001b[32m2025-05-30 11:05:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/164 - loss=1.0905222, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.1932961, MSE_maskV_-1.0=1.0912144, val_loss=0.89028788, val_CC_maskV_-1.0=0.3349863, val_MSE_maskV_-1.0=0.88888264, learning_rate=0.001\n", + "Epoch 18/164 - loss=0.65563667, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58390039, MSE_maskV_-1.0=0.65562165, val_loss=0.67771965, val_CC_maskV_-1.0=0.56613803, val_MSE_maskV_-1.0=0.67636955, learning_rate=0.001\n", + "Epoch 35/164 - loss=0.62956852, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60625219, MSE_maskV_-1.0=0.62931275, val_loss=0.65969998, val_CC_maskV_-1.0=0.58133912, val_MSE_maskV_-1.0=0.65830755, learning_rate=0.001\n", + "Epoch 52/164 - loss=0.61753327, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61584419, MSE_maskV_-1.0=0.61796266, val_loss=0.65572464, val_CC_maskV_-1.0=0.5846808, val_MSE_maskV_-1.0=0.65439671, learning_rate=0.001\n", + "Epoch 69/164 - loss=0.60983551, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62260926, MSE_maskV_-1.0=0.60979277, val_loss=0.64741385, val_CC_maskV_-1.0=0.59156001, val_MSE_maskV_-1.0=0.64569712, learning_rate=0.001\n", + "Epoch 86/164 - loss=0.60467613, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62594676, MSE_maskV_-1.0=0.60447967, val_loss=0.64437294, val_CC_maskV_-1.0=0.5946551, val_MSE_maskV_-1.0=0.64266902, learning_rate=0.001\n", + "Epoch 103/164 - loss=0.59974593, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62899452, MSE_maskV_-1.0=0.59947425, val_loss=0.64424133, val_CC_maskV_-1.0=0.59667885, val_MSE_maskV_-1.0=0.64175951, learning_rate=0.001\n", + "Epoch 120/164 - loss=0.59526068, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63247967, MSE_maskV_-1.0=0.59555006, val_loss=0.64206159, val_CC_maskV_-1.0=0.59735614, val_MSE_maskV_-1.0=0.64035934, learning_rate=0.001\n", + "Epoch 137/164 - loss=0.59196347, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63583785, MSE_maskV_-1.0=0.59161299, val_loss=0.64158756, val_CC_maskV_-1.0=0.5975852, val_MSE_maskV_-1.0=0.63994747, learning_rate=0.001\n", + "Epoch 154/164 - loss=0.59022969, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63690293, MSE_maskV_-1.0=0.58995205, val_loss=0.63970053, val_CC_maskV_-1.0=0.59961271, val_MSE_maskV_-1.0=0.63798612, learning_rate=0.001\n", + "Epoch 164/164 - loss=0.58852524, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63808978, MSE_maskV_-1.0=0.58817297, val_loss=0.64006931, val_CC_maskV_-1.0=0.59982854, val_MSE_maskV_-1.0=0.63848096, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:05:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 44.62s\n", + "\u001b[32m2025-05-30 11:05:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.62391019)\n", + "\u001b[32m2025-05-30 11:05:36\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 777us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:05:37\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.584, R2_maskV_-1.0=0.417, CC_maskV_-1.0=0.645\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 825us/step\n", + "51/51 [==============================] - 0s 898us/step\n", + "84/84 [==============================] - 0s 762us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:05:38\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_ACzCy1HL64U_ErSV16\" (14/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_ACzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:05:38\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_KCzCy1HL64U_ErSV16\" (15/16)\n", + "\u001b[32m2025-05-30 11:05:38\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:05:38\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:05:38\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:05:38\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:05:38\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:05:38\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:05:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:05:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 97 (stopped at 112 epochs).\n", + "\u001b[32m2025-05-30 11:05:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/113 - loss=rnn_1step_loss=0.99944288, rnn_1step_R2_maskV_-1.0=-0.022381127, rnn_1step_CC_maskV_-1.0=0.037666306, rnn_1step_MSE_maskV_-1.0=0.99944293, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96546125, val_rnn_1step_R2_maskV_-1.0=-0.088240728, val_rnn_1step_CC_maskV_-1.0=0.28014639, learning_rate=0.001\n", + "Epoch 13/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.84096104, rnn_1step_R2_maskV_-1.0=0.13707113, rnn_1step_CC_maskV_-1.0=0.39953765, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.80209804, val_rnn_1step_R2_maskV_-1.0=0.091812417, val_rnn_1step_CC_maskV_-1.0=0.42466742, learning_rate=0.001\n", + "Epoch 25/113 - loss=rnn_1step_loss=0.62608737, rnn_1step_R2_maskV_-1.0=0.35391399, rnn_1step_CC_maskV_-1.0=0.61442214, rnn_1step_MSE_maskV_-1.0=0.62608731, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.65105325, val_rnn_1step_R2_maskV_-1.0=0.25541717, val_rnn_1step_CC_maskV_-1.0=0.57240468, learning_rate=0.001\n", + "Epoch 37/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.50632018, rnn_1step_R2_maskV_-1.0=0.47646096, rnn_1step_CC_maskV_-1.0=0.70231855, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59887981, val_rnn_1step_R2_maskV_-1.0=0.31372041, val_rnn_1step_CC_maskV_-1.0=0.62514126, learning_rate=0.001\n", + "Epoch 49/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39336109, rnn_1step_R2_maskV_-1.0=0.59468627, rnn_1step_CC_maskV_-1.0=0.77746516, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54710561, val_rnn_1step_R2_maskV_-1.0=0.37447259, val_rnn_1step_CC_maskV_-1.0=0.6738078, learning_rate=0.001\n", + "Epoch 61/113 - loss=rnn_1step_loss=0.32004136, rnn_1step_R2_maskV_-1.0=0.67071486, rnn_1step_CC_maskV_-1.0=0.82356423, rnn_1step_MSE_maskV_-1.0=0.32004133, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50394154, val_rnn_1step_R2_maskV_-1.0=0.42427662, val_rnn_1step_CC_maskV_-1.0=0.70386821, learning_rate=0.001\n", + "Epoch 73/113 - loss=rnn_1step_loss=0.27743188, rnn_1step_R2_maskV_-1.0=0.71456265, rnn_1step_CC_maskV_-1.0=0.84900182, rnn_1step_MSE_maskV_-1.0=0.27743191, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49092683, val_rnn_1step_R2_maskV_-1.0=0.43928334, val_rnn_1step_CC_maskV_-1.0=0.71484876, learning_rate=0.001\n", + "Epoch 85/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.2524431, rnn_1step_R2_maskV_-1.0=0.7397747, rnn_1step_CC_maskV_-1.0=0.86360538, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48565209, val_rnn_1step_R2_maskV_-1.0=0.4446905, val_rnn_1step_CC_maskV_-1.0=0.71870369, learning_rate=0.001\n", + "Epoch 97/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.2382499, rnn_1step_R2_maskV_-1.0=0.75412554, rnn_1step_CC_maskV_-1.0=0.87232822, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47549447, val_rnn_1step_R2_maskV_-1.0=0.45578995, val_rnn_1step_CC_maskV_-1.0=0.71998161, learning_rate=0.001\n", + "Epoch 109/113 - loss=rnn_1step_loss=0.22319525, rnn_1step_R2_maskV_-1.0=0.7695936, rnn_1step_CC_maskV_-1.0=0.88058382, rnn_1step_MSE_maskV_-1.0=0.22319527, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48790383, val_rnn_1step_R2_maskV_-1.0=0.44138187, val_rnn_1step_CC_maskV_-1.0=0.71814442, learning_rate=0.001\n", + "Epoch 113/113 - loss=rnn_1step_loss=0.21931028, rnn_1step_R2_maskV_-1.0=0.77362311, rnn_1step_CC_maskV_-1.0=0.88272095, rnn_1step_MSE_maskV_-1.0=0.2193103, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48965359, val_rnn_1step_R2_maskV_-1.0=0.4392789, val_rnn_1step_CC_maskV_-1.0=0.7179293, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:05:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.33s\n", + "\u001b[32m2025-05-30 11:05:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:06:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 103 (stopped at 118 epochs).\n", + "\u001b[32m2025-05-30 11:06:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/119 - loss=rnn_1_1step_loss=0.99949628, rnn_1_1step_R2_maskV_-1.0=-0.022424817, rnn_1_1step_CC_maskV_-1.0=-0.00049404427, rnn_1_1step_MSE_maskV_-1.0=0.99949622, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96565574, val_rnn_1_1step_R2_maskV_-1.0=-0.088506415, val_rnn_1_1step_CC_maskV_-1.0=0.25679046, learning_rate=0.001\n", + "Epoch 13/119 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.8508873, rnn_1_1step_R2_maskV_-1.0=0.12584834, rnn_1_1step_CC_maskV_-1.0=0.38772896, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.81961775, val_rnn_1_1step_R2_maskV_-1.0=0.06577833, val_rnn_1_1step_CC_maskV_-1.0=0.39149487, learning_rate=0.001\n", + "Epoch 25/119 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.67299336, rnn_1_1step_R2_maskV_-1.0=0.30283257, rnn_1_1step_CC_maskV_-1.0=0.57169533, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.70616531, val_rnn_1_1step_R2_maskV_-1.0=0.19275153, val_rnn_1_1step_CC_maskV_-1.0=0.52262688, learning_rate=0.001\n", + "Epoch 37/119 - loss=rnn_1_1step_loss=0.56064457, rnn_1_1step_R2_maskV_-1.0=0.4187665, rnn_1_1step_CC_maskV_-1.0=0.66170233, rnn_1_1step_MSE_maskV_-1.0=0.56064463, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.66820145, val_rnn_1_1step_R2_maskV_-1.0=0.23712245, val_rnn_1_1step_CC_maskV_-1.0=0.56435221, learning_rate=0.001\n", + "Epoch 49/119 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.46802354, rnn_1_1step_R2_maskV_-1.0=0.51526624, rnn_1_1step_CC_maskV_-1.0=0.72775024, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59318382, val_rnn_1_1step_R2_maskV_-1.0=0.322743, val_rnn_1_1step_CC_maskV_-1.0=0.62508744, learning_rate=0.001\n", + "Epoch 61/119 - loss=rnn_1_1step_loss=0.39298382, rnn_1_1step_R2_maskV_-1.0=0.59265256, rnn_1_1step_CC_maskV_-1.0=0.77754879, rnn_1_1step_MSE_maskV_-1.0=0.39298385, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53419155, val_rnn_1_1step_R2_maskV_-1.0=0.38972008, val_rnn_1_1step_CC_maskV_-1.0=0.67042547, learning_rate=0.001\n", + "Epoch 73/119 - loss=rnn_1_1step_loss=0.35103628, rnn_1_1step_R2_maskV_-1.0=0.63580704, rnn_1_1step_CC_maskV_-1.0=0.80415154, rnn_1_1step_MSE_maskV_-1.0=0.35103622, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51089716, val_rnn_1_1step_R2_maskV_-1.0=0.41595179, val_rnn_1_1step_CC_maskV_-1.0=0.68769145, learning_rate=0.001\n", + "Epoch 85/119 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32305723, rnn_1_1step_R2_maskV_-1.0=0.66469246, rnn_1_1step_CC_maskV_-1.0=0.82170784, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49311194, val_rnn_1_1step_R2_maskV_-1.0=0.43701133, val_rnn_1_1step_CC_maskV_-1.0=0.69825661, learning_rate=0.001\n", + "Epoch 97/119 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.29506478, rnn_1_1step_R2_maskV_-1.0=0.69381583, rnn_1_1step_CC_maskV_-1.0=0.83919281, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49894309, val_rnn_1_1step_R2_maskV_-1.0=0.42914778, val_rnn_1_1step_CC_maskV_-1.0=0.70239878, learning_rate=0.001\n", + "Epoch 109/119 - loss=rnn_1_1step_loss=0.26888099, rnn_1_1step_R2_maskV_-1.0=0.72122312, rnn_1_1step_CC_maskV_-1.0=0.85469842, rnn_1_1step_MSE_maskV_-1.0=0.26888102, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48312986, val_rnn_1_1step_R2_maskV_-1.0=0.44786766, val_rnn_1_1step_CC_maskV_-1.0=0.71189594, learning_rate=0.001\n", + "Epoch 119/119 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.25076795, rnn_1_1step_R2_maskV_-1.0=0.7400521, rnn_1_1step_CC_maskV_-1.0=0.86468327, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4750917, val_rnn_1_1step_R2_maskV_-1.0=0.45745817, val_rnn_1_1step_CC_maskV_-1.0=0.71528691, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:06:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.80s\n", + "\u001b[32m2025-05-30 11:06:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.47437182)\n", + "\u001b[32m2025-05-30 11:06:08\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.269, R2_maskV_-1.0=0.731, CC_maskV_-1.0=0.855\n", + "\u001b[32m2025-05-30 11:06:09\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.457, R2_maskV_-1.0=0.494, CC_maskV_-1.0=0.731\n", + "\u001b[32m2025-05-30 11:06:09\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:06:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:06:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 168 (stopped at 183 epochs).\n", + "\u001b[32m2025-05-30 11:06:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/184 - loss=1.2412387, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.11147226, MSE_maskV_-1.0=1.242594, val_loss=0.9750936, val_CC_maskV_-1.0=0.19542325, val_MSE_maskV_-1.0=0.97143883, learning_rate=0.001\n", + "Epoch 20/184 - loss=0.80315995, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44470933, MSE_maskV_-1.0=0.80296552, val_loss=0.81893301, val_CC_maskV_-1.0=0.43303823, val_MSE_maskV_-1.0=0.81752044, learning_rate=0.001\n", + "Epoch 39/184 - loss=0.77264756, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47657531, MSE_maskV_-1.0=0.77332598, val_loss=0.79042476, val_CC_maskV_-1.0=0.46352243, val_MSE_maskV_-1.0=0.78917253, learning_rate=0.001\n", + "Epoch 58/184 - loss=0.75493956, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49533662, MSE_maskV_-1.0=0.7544232, val_loss=0.78205323, val_CC_maskV_-1.0=0.47173873, val_MSE_maskV_-1.0=0.78133184, learning_rate=0.001\n", + "Epoch 77/184 - loss=0.74358636, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50632519, MSE_maskV_-1.0=0.74307585, val_loss=0.76896286, val_CC_maskV_-1.0=0.48662233, val_MSE_maskV_-1.0=0.76726896, learning_rate=0.001\n", + "Epoch 96/184 - loss=0.73532295, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51470202, MSE_maskV_-1.0=0.73502773, val_loss=0.76798713, val_CC_maskV_-1.0=0.48714095, val_MSE_maskV_-1.0=0.76643461, learning_rate=0.001\n", + "Epoch 115/184 - loss=0.73049122, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51944739, MSE_maskV_-1.0=0.73021626, val_loss=0.76437706, val_CC_maskV_-1.0=0.49070138, val_MSE_maskV_-1.0=0.76318097, learning_rate=0.001\n", + "Epoch 134/184 - loss=0.72744906, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52154052, MSE_maskV_-1.0=0.72733712, val_loss=0.7597723, val_CC_maskV_-1.0=0.49436381, val_MSE_maskV_-1.0=0.75897723, learning_rate=0.001\n", + "Epoch 153/184 - loss=0.72180504, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52765471, MSE_maskV_-1.0=0.72127187, val_loss=0.75850493, val_CC_maskV_-1.0=0.49631476, val_MSE_maskV_-1.0=0.75731677, learning_rate=0.001\n", + "Epoch 172/184 - loss=0.71883106, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53064692, MSE_maskV_-1.0=0.72075498, val_loss=0.75637692, val_CC_maskV_-1.0=0.49915662, val_MSE_maskV_-1.0=0.7548399, learning_rate=0.001\n", + "Epoch 184/184 - loss=0.71653402, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53183895, MSE_maskV_-1.0=0.71632582, val_loss=0.75715643, val_CC_maskV_-1.0=0.4983702, val_MSE_maskV_-1.0=0.75555599, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:06:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 47.77s\n", + "\u001b[32m2025-05-30 11:06:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:07:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 171 (stopped at 186 epochs).\n", + "\u001b[32m2025-05-30 11:07:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/187 - loss=1.1678373, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.1264251, MSE_maskV_-1.0=1.1693201, val_loss=0.96624362, val_CC_maskV_-1.0=0.2096559, val_MSE_maskV_-1.0=0.96335596, learning_rate=0.001\n", + "Epoch 20/187 - loss=0.79837632, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4503378, MSE_maskV_-1.0=0.79823989, val_loss=0.81436348, val_CC_maskV_-1.0=0.43767905, val_MSE_maskV_-1.0=0.81263596, learning_rate=0.001\n", + "Epoch 39/187 - loss=0.76724851, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4823876, MSE_maskV_-1.0=0.76790971, val_loss=0.7867229, val_CC_maskV_-1.0=0.46771088, val_MSE_maskV_-1.0=0.78484613, learning_rate=0.001\n", + "Epoch 58/187 - loss=0.74967152, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50074172, MSE_maskV_-1.0=0.74921769, val_loss=0.78143209, val_CC_maskV_-1.0=0.4702172, val_MSE_maskV_-1.0=0.78169864, learning_rate=0.001\n", + "Epoch 77/187 - loss=0.73971266, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.510144, MSE_maskV_-1.0=0.73921895, val_loss=0.76373953, val_CC_maskV_-1.0=0.49103138, val_MSE_maskV_-1.0=0.76239711, learning_rate=0.001\n", + "Epoch 96/187 - loss=0.73360771, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51628625, MSE_maskV_-1.0=0.73336285, val_loss=0.76243967, val_CC_maskV_-1.0=0.49074301, val_MSE_maskV_-1.0=0.7618506, learning_rate=0.001\n", + "Epoch 115/187 - loss=0.72756594, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52225918, MSE_maskV_-1.0=0.72725159, val_loss=0.76282018, val_CC_maskV_-1.0=0.4913879, val_MSE_maskV_-1.0=0.76170838, learning_rate=0.001\n", + "Epoch 134/187 - loss=0.72487307, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52395993, MSE_maskV_-1.0=0.72472697, val_loss=0.75470597, val_CC_maskV_-1.0=0.49895847, val_MSE_maskV_-1.0=0.75386751, learning_rate=0.001\n", + "Epoch 153/187 - loss=0.71920705, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52999693, MSE_maskV_-1.0=0.71871924, val_loss=0.75784642, val_CC_maskV_-1.0=0.49582252, val_MSE_maskV_-1.0=0.75724655, learning_rate=0.001\n", + "Epoch 172/187 - loss=0.71670741, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53254151, MSE_maskV_-1.0=0.71878439, val_loss=0.75730562, val_CC_maskV_-1.0=0.49746895, val_MSE_maskV_-1.0=0.75650281, learning_rate=0.001\n", + "Epoch 187/187 - loss=0.71554315, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53272754, MSE_maskV_-1.0=0.71589988, val_loss=0.76096439, val_CC_maskV_-1.0=0.49411169, val_MSE_maskV_-1.0=0.76026744, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:07:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 48.65s\n", + "\u001b[32m2025-05-30 11:07:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.7494697)\n", + "\u001b[32m2025-05-30 11:07:45\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 791us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:07:45\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.712, R2_maskV_-1.0=0.288, CC_maskV_-1.0=0.536\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 842us/step\n", + "51/51 [==============================] - 0s 833us/step\n", + "84/84 [==============================] - 0s 770us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:07:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_KCzCy1HL64U_ErSV16\" (15/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_KCzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:07:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16\" (16/16)\n", + "\u001b[32m2025-05-30 11:07:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:07:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:07:46\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:07:46\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:07:46\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:07:46\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:07:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:08:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 120 (stopped at 135 epochs).\n", + "\u001b[32m2025-05-30 11:08:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/136 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.99942017, rnn_1step_R2_maskV_-1.0=-0.022345807, rnn_1step_CC_maskV_-1.0=0.021972628, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96572661, val_rnn_1step_R2_maskV_-1.0=-0.088540882, val_rnn_1step_CC_maskV_-1.0=0.24311949, learning_rate=0.001\n", + "Epoch 15/136 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.79323918, rnn_1step_R2_maskV_-1.0=0.18208465, rnn_1step_CC_maskV_-1.0=0.46367306, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.80675668, val_rnn_1step_R2_maskV_-1.0=0.078388065, val_rnn_1step_CC_maskV_-1.0=0.38878217, learning_rate=0.001\n", + "Epoch 29/136 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.63468915, rnn_1step_R2_maskV_-1.0=0.3376565, rnn_1step_CC_maskV_-1.0=0.60340142, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.71013123, val_rnn_1step_R2_maskV_-1.0=0.1911511, val_rnn_1step_CC_maskV_-1.0=0.51876855, learning_rate=0.001\n", + "Epoch 43/136 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.57962793, rnn_1step_R2_maskV_-1.0=0.39456803, rnn_1step_CC_maskV_-1.0=0.64745814, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.70715946, val_rnn_1step_R2_maskV_-1.0=0.19887201, val_rnn_1step_CC_maskV_-1.0=0.52298951, learning_rate=0.001\n", + "Epoch 57/136 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.49195862, rnn_1step_R2_maskV_-1.0=0.48795414, rnn_1step_CC_maskV_-1.0=0.71173978, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64589387, val_rnn_1step_R2_maskV_-1.0=0.26512831, val_rnn_1step_CC_maskV_-1.0=0.58275038, learning_rate=0.001\n", + "Epoch 71/136 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41223025, rnn_1step_R2_maskV_-1.0=0.57156575, rnn_1step_CC_maskV_-1.0=0.76657254, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56837124, val_rnn_1step_R2_maskV_-1.0=0.35223842, val_rnn_1step_CC_maskV_-1.0=0.64211774, learning_rate=0.001\n", + "Epoch 85/136 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.36707115, rnn_1step_R2_maskV_-1.0=0.61822248, rnn_1step_CC_maskV_-1.0=0.7953552, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52811301, val_rnn_1step_R2_maskV_-1.0=0.3983871, val_rnn_1step_CC_maskV_-1.0=0.67283535, learning_rate=0.001\n", + "Epoch 99/136 - loss=rnn_1step_loss=0.33785829, rnn_1step_R2_maskV_-1.0=0.64837414, rnn_1step_CC_maskV_-1.0=0.81410575, rnn_1step_MSE_maskV_-1.0=0.33785832, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51400346, val_rnn_1step_R2_maskV_-1.0=0.41379982, val_rnn_1step_CC_maskV_-1.0=0.68556887, learning_rate=0.001\n", + "Epoch 113/136 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3123537, rnn_1step_R2_maskV_-1.0=0.67523646, rnn_1step_CC_maskV_-1.0=0.82861185, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52008671, val_rnn_1step_R2_maskV_-1.0=0.40492076, val_rnn_1step_CC_maskV_-1.0=0.69010973, learning_rate=0.001\n", + "Epoch 127/136 - loss=rnn_1step_loss=0.29456607, rnn_1step_R2_maskV_-1.0=0.69357085, rnn_1step_CC_maskV_-1.0=0.83898634, rnn_1step_MSE_maskV_-1.0=0.29456609, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50872701, val_rnn_1step_R2_maskV_-1.0=0.41870767, val_rnn_1step_CC_maskV_-1.0=0.69804424, learning_rate=0.001\n", + "Epoch 136/136 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.28786945, rnn_1step_R2_maskV_-1.0=0.70059103, rnn_1step_CC_maskV_-1.0=0.84316862, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5144875, val_rnn_1step_R2_maskV_-1.0=0.41161883, val_rnn_1step_CC_maskV_-1.0=0.69690871, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:08:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 16.61s\n", + "\u001b[32m2025-05-30 11:08:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:08:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 87 (stopped at 102 epochs).\n", + "\u001b[32m2025-05-30 11:08:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/103 - loss=rnn_1_1step_loss=0.99944073, rnn_1_1step_R2_maskV_-1.0=-0.022366401, rnn_1_1step_CC_maskV_-1.0=0.036053963, rnn_1_1step_MSE_maskV_-1.0=0.99944079, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96551865, val_rnn_1_1step_R2_maskV_-1.0=-0.088330463, val_rnn_1_1step_CC_maskV_-1.0=0.24478607, learning_rate=0.001\n", + "Epoch 12/103 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.77935916, rnn_1_1step_R2_maskV_-1.0=0.20075971, rnn_1_1step_CC_maskV_-1.0=0.48291755, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.76472718, val_rnn_1_1step_R2_maskV_-1.0=0.13064133, val_rnn_1_1step_CC_maskV_-1.0=0.47239006, learning_rate=0.001\n", + "Epoch 23/103 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.62260228, rnn_1_1step_R2_maskV_-1.0=0.35333094, rnn_1_1step_CC_maskV_-1.0=0.61490023, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.67534876, val_rnn_1_1step_R2_maskV_-1.0=0.22825146, val_rnn_1_1step_CC_maskV_-1.0=0.54535478, learning_rate=0.001\n", + "Epoch 34/103 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.55305964, rnn_1_1step_R2_maskV_-1.0=0.42371252, rnn_1_1step_CC_maskV_-1.0=0.66883039, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64061207, val_rnn_1_1step_R2_maskV_-1.0=0.26916891, val_rnn_1_1step_CC_maskV_-1.0=0.57874215, learning_rate=0.001\n", + "Epoch 45/103 - loss=rnn_1_1step_loss=0.48918366, rnn_1_1step_R2_maskV_-1.0=0.4899247, rnn_1_1step_CC_maskV_-1.0=0.71397412, rnn_1_1step_MSE_maskV_-1.0=0.4891836, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60891622, val_rnn_1_1step_R2_maskV_-1.0=0.30319673, val_rnn_1_1step_CC_maskV_-1.0=0.60797507, learning_rate=0.001\n", + "Epoch 56/103 - loss=rnn_1_1step_loss=0.44129455, rnn_1_1step_R2_maskV_-1.0=0.53972346, rnn_1_1step_CC_maskV_-1.0=0.74674153, rnn_1_1step_MSE_maskV_-1.0=0.44129458, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56749159, val_rnn_1_1step_R2_maskV_-1.0=0.3493098, val_rnn_1_1step_CC_maskV_-1.0=0.64104056, learning_rate=0.001\n", + "Epoch 67/103 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41264781, rnn_1_1step_R2_maskV_-1.0=0.5695225, rnn_1_1step_CC_maskV_-1.0=0.76500857, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54796475, val_rnn_1_1step_R2_maskV_-1.0=0.37166128, val_rnn_1_1step_CC_maskV_-1.0=0.65367597, learning_rate=0.001\n", + "Epoch 78/103 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38973665, rnn_1_1step_R2_maskV_-1.0=0.59269202, rnn_1_1step_CC_maskV_-1.0=0.78109485, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5574736, val_rnn_1_1step_R2_maskV_-1.0=0.35964072, val_rnn_1_1step_CC_maskV_-1.0=0.65479696, learning_rate=0.001\n", + "Epoch 89/103 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36895955, rnn_1_1step_R2_maskV_-1.0=0.61412263, rnn_1_1step_CC_maskV_-1.0=0.79569316, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54414672, val_rnn_1_1step_R2_maskV_-1.0=0.37470865, val_rnn_1_1step_CC_maskV_-1.0=0.66498244, learning_rate=0.001\n", + "Epoch 100/103 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.34345141, rnn_1_1step_R2_maskV_-1.0=0.64083958, rnn_1_1step_CC_maskV_-1.0=0.8094539, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52084225, val_rnn_1_1step_R2_maskV_-1.0=0.40268055, val_rnn_1_1step_CC_maskV_-1.0=0.6805591, learning_rate=0.001\n", + "Epoch 103/103 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.34202829, rnn_1_1step_R2_maskV_-1.0=0.64267063, rnn_1_1step_CC_maskV_-1.0=0.81031537, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51885277, val_rnn_1_1step_R2_maskV_-1.0=0.40502095, val_rnn_1_1step_CC_maskV_-1.0=0.68132311, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:08:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 13.04s\n", + "\u001b[32m2025-05-30 11:08:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.49239269)\n", + "\u001b[32m2025-05-30 11:08:18\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.294, R2_maskV_-1.0=0.707, CC_maskV_-1.0=0.841\n", + "\u001b[32m2025-05-30 11:08:18\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.488, R2_maskV_-1.0=0.457, CC_maskV_-1.0=0.715\n", + "\u001b[32m2025-05-30 11:08:18\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:08:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:09:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 179 (stopped at 194 epochs).\n", + "\u001b[32m2025-05-30 11:09:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/195 - loss=1.0432898, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.16384962, MSE_maskV_-1.0=1.0450242, val_loss=0.93695515, val_CC_maskV_-1.0=0.26636964, val_MSE_maskV_-1.0=0.9335838, learning_rate=0.001\n", + "Epoch 21/195 - loss=0.80331349, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44407749, MSE_maskV_-1.0=0.80311167, val_loss=0.81887859, val_CC_maskV_-1.0=0.43051928, val_MSE_maskV_-1.0=0.81623197, learning_rate=0.001\n", + "Epoch 41/195 - loss=0.77202863, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47642294, MSE_maskV_-1.0=0.77236772, val_loss=0.79383147, val_CC_maskV_-1.0=0.45538259, val_MSE_maskV_-1.0=0.79098189, learning_rate=0.001\n", + "Epoch 61/195 - loss=0.75295383, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49609292, MSE_maskV_-1.0=0.7524783, val_loss=0.77484035, val_CC_maskV_-1.0=0.47549972, val_MSE_maskV_-1.0=0.77150261, learning_rate=0.001\n", + "Epoch 81/195 - loss=0.73851341, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51078081, MSE_maskV_-1.0=0.73837721, val_loss=0.7677514, val_CC_maskV_-1.0=0.4813593, val_MSE_maskV_-1.0=0.76493925, learning_rate=0.001\n", + "Epoch 101/195 - loss=0.72759312, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52089614, MSE_maskV_-1.0=0.72759736, val_loss=0.75616497, val_CC_maskV_-1.0=0.49426463, val_MSE_maskV_-1.0=0.75161391, learning_rate=0.001\n", + "Epoch 121/195 - loss=0.72048116, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52731532, MSE_maskV_-1.0=0.72039551, val_loss=0.75780588, val_CC_maskV_-1.0=0.49223754, val_MSE_maskV_-1.0=0.7536698, learning_rate=0.001\n", + "Epoch 141/195 - loss=0.71452111, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53235161, MSE_maskV_-1.0=0.71819735, val_loss=0.75191611, val_CC_maskV_-1.0=0.49783844, val_MSE_maskV_-1.0=0.74774468, learning_rate=0.001\n", + "Epoch 161/195 - loss=0.71041423, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53666818, MSE_maskV_-1.0=0.71056831, val_loss=0.7487762, val_CC_maskV_-1.0=0.50208807, val_MSE_maskV_-1.0=0.7444548, learning_rate=0.001\n", + "Epoch 181/195 - loss=0.70711762, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53917295, MSE_maskV_-1.0=0.70701522, val_loss=0.74721342, val_CC_maskV_-1.0=0.50175911, val_MSE_maskV_-1.0=0.7432434, learning_rate=0.001\n", + "Epoch 195/195 - loss=0.70545858, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54002166, MSE_maskV_-1.0=0.7051779, val_loss=0.74370533, val_CC_maskV_-1.0=0.50608355, val_MSE_maskV_-1.0=0.73925096, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:09:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 51.70s\n", + "\u001b[32m2025-05-30 11:09:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:09:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 165 (stopped at 180 epochs).\n", + "\u001b[32m2025-05-30 11:09:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/181 - loss=1.0642076, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.15783888, MSE_maskV_-1.0=1.0659634, val_loss=0.93893665, val_CC_maskV_-1.0=0.2666218, val_MSE_maskV_-1.0=0.93434322, learning_rate=0.001\n", + "Epoch 20/181 - loss=0.81114531, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4356702, MSE_maskV_-1.0=0.81118602, val_loss=0.82565778, val_CC_maskV_-1.0=0.42570412, val_MSE_maskV_-1.0=0.82257921, learning_rate=0.001\n", + "Epoch 39/181 - loss=0.77449393, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4743804, MSE_maskV_-1.0=0.77499342, val_loss=0.79225671, val_CC_maskV_-1.0=0.45832458, val_MSE_maskV_-1.0=0.78908753, learning_rate=0.001\n", + "Epoch 58/181 - loss=0.75219804, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49726188, MSE_maskV_-1.0=0.75158572, val_loss=0.77898878, val_CC_maskV_-1.0=0.47058609, val_MSE_maskV_-1.0=0.77624345, learning_rate=0.001\n", + "Epoch 77/181 - loss=0.73895353, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51008832, MSE_maskV_-1.0=0.73840433, val_loss=0.76456285, val_CC_maskV_-1.0=0.48489287, val_MSE_maskV_-1.0=0.76166719, learning_rate=0.001\n", + "Epoch 96/181 - loss=0.72992873, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51773375, MSE_maskV_-1.0=0.72970647, val_loss=0.76023877, val_CC_maskV_-1.0=0.48894149, val_MSE_maskV_-1.0=0.75727934, learning_rate=0.001\n", + "Epoch 115/181 - loss=0.7234264, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52534962, MSE_maskV_-1.0=0.72291362, val_loss=0.75439233, val_CC_maskV_-1.0=0.49519154, val_MSE_maskV_-1.0=0.75087768, learning_rate=0.001\n", + "Epoch 134/181 - loss=0.71857899, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52835602, MSE_maskV_-1.0=0.71855891, val_loss=0.75188071, val_CC_maskV_-1.0=0.49775803, val_MSE_maskV_-1.0=0.74820971, learning_rate=0.001\n", + "Epoch 153/181 - loss=0.71411794, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53321487, MSE_maskV_-1.0=0.71358967, val_loss=0.74831259, val_CC_maskV_-1.0=0.50027084, val_MSE_maskV_-1.0=0.74517268, learning_rate=0.001\n", + "Epoch 172/181 - loss=0.71038449, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53670079, MSE_maskV_-1.0=0.71109879, val_loss=0.75004494, val_CC_maskV_-1.0=0.49922901, val_MSE_maskV_-1.0=0.74694818, learning_rate=0.001\n", + "Epoch 181/181 - loss=0.70948619, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53685451, MSE_maskV_-1.0=0.70939946, val_loss=0.74763238, val_CC_maskV_-1.0=0.50071341, val_MSE_maskV_-1.0=0.74484193, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:09:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 47.83s\n", + "\u001b[32m2025-05-30 11:09:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.7424261)\n", + "\u001b[32m2025-05-30 11:09:57\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 797us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:09:58\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.704, R2_maskV_-1.0=0.297, CC_maskV_-1.0=0.544\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 756us/step\n", + "51/51 [==============================] - 0s 753us/step\n", + "84/84 [==============================] - 0s 736us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:09:58\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16\" (16/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_uAKCzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:09:58\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1948] \u001b[1;30mINFO\u001b[0m Saving results for fold 1 as ..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4.p\n", + "\u001b[32m2025-05-30 11:09:58\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1381] \u001b[1;30mINFO\u001b[0m Fold 2/4: training samples: 8014, test samples=2672\n", + "\u001b[32m2025-05-30 11:09:58\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1754] \u001b[1;30mINFO\u001b[0m Running fold 2 (NTrain=8014, NTest=2672)\n", + "\u001b[32m2025-05-30 11:09:58\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1849] \u001b[1;30mINFO\u001b[0m Signal dimensions: y => (10686, 46), z => (10686, 4), u => None\n", + "\u001b[32m2025-05-30 11:09:58\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1856] \u001b[1;30mINFO\u001b[0m Method codes to fit: ['DPAD_RTR2_ErSV16', 'DPAD_RTR2_A1HL64U_ErSV16', 'DPAD_RTR2_K1HL64U_ErSV16', 'DPAD_RTR2_Cz1HL64U_ErSV16', 'DPAD_RTR2_Cy1HL64U_ErSV16', 'DPAD_RTR2_uAK1HL64U_ErSV16', 'DPAD_RTR2_ACz1HL64U_ErSV16', 'DPAD_RTR2_ACy1HL64U_ErSV16', 'DPAD_RTR2_KCz1HL64U_ErSV16', 'DPAD_RTR2_KCy1HL64U_ErSV16', 'DPAD_RTR2_CzCy1HL64U_ErSV16', 'DPAD_RTR2_uAKCz1HL64U_ErSV16', 'DPAD_RTR2_uAKCy1HL64U_ErSV16', 'DPAD_RTR2_ACzCy1HL64U_ErSV16', 'DPAD_RTR2_KCzCy1HL64U_ErSV16', 'DPAD_RTR2_uAKCzCy1HL64U_ErSV16']\n", + "\u001b[32m2025-05-30 11:09:58\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1857] \u001b[1;30mINFO\u001b[0m Nx values to fit: [16]\n", + "\u001b[32m2025-05-30 11:09:59\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_ErSV16\" (1/16)\n", + "\u001b[32m2025-05-30 11:09:59\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:09:59\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:09:59\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:09:59\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:09:59\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:09:59\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:09:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:11:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 691 (stopped at 706 epochs).\n", + "\u001b[32m2025-05-30 11:11:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/707 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0003805, rnn_1step_R2_maskV_-1.0=-0.012991704, rnn_1step_CC_maskV_-1.0=0.036483116, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91786623, val_rnn_1step_R2_maskV_-1.0=-0.058724523, val_rnn_1step_CC_maskV_-1.0=0.14198536, learning_rate=0.001\n", + "Epoch 72/707 - loss=rnn_1step_loss=0.45908001, rnn_1step_R2_maskV_-1.0=0.53340203, rnn_1step_CC_maskV_-1.0=0.73549402, rnn_1step_MSE_maskV_-1.0=0.45908004, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56444949, val_rnn_1step_R2_maskV_-1.0=0.33933842, val_rnn_1step_CC_maskV_-1.0=0.63946414, learning_rate=0.001\n", + "Epoch 143/707 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41000652, rnn_1step_R2_maskV_-1.0=0.58374989, rnn_1step_CC_maskV_-1.0=0.76766902, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51342559, val_rnn_1step_R2_maskV_-1.0=0.39672887, val_rnn_1step_CC_maskV_-1.0=0.68116951, learning_rate=0.001\n", + "Epoch 214/707 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39534232, rnn_1step_R2_maskV_-1.0=0.59876138, rnn_1step_CC_maskV_-1.0=0.77697831, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50680631, val_rnn_1step_R2_maskV_-1.0=0.40406287, val_rnn_1step_CC_maskV_-1.0=0.68936914, learning_rate=0.001\n", + "Epoch 285/707 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39125714, rnn_1step_R2_maskV_-1.0=0.60286742, rnn_1step_CC_maskV_-1.0=0.77954912, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50664169, val_rnn_1step_R2_maskV_-1.0=0.40449229, val_rnn_1step_CC_maskV_-1.0=0.6909917, learning_rate=0.001\n", + "Epoch 356/707 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38895416, rnn_1step_R2_maskV_-1.0=0.60511577, rnn_1step_CC_maskV_-1.0=0.78099597, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50635934, val_rnn_1step_R2_maskV_-1.0=0.40496594, val_rnn_1step_CC_maskV_-1.0=0.69209945, learning_rate=0.001\n", + "Epoch 427/707 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38696763, rnn_1step_R2_maskV_-1.0=0.60699612, rnn_1step_CC_maskV_-1.0=0.78227484, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50571638, val_rnn_1step_R2_maskV_-1.0=0.40584034, val_rnn_1step_CC_maskV_-1.0=0.69303322, learning_rate=0.001\n", + "Epoch 498/707 - loss=rnn_1step_loss=0.38469699, rnn_1step_R2_maskV_-1.0=0.60916221, rnn_1step_CC_maskV_-1.0=0.78375936, rnn_1step_MSE_maskV_-1.0=0.38469702, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50408119, val_rnn_1step_R2_maskV_-1.0=0.40788412, val_rnn_1step_CC_maskV_-1.0=0.69432616, learning_rate=0.001\n", + "Epoch 569/707 - loss=rnn_1step_loss=0.38272345, rnn_1step_R2_maskV_-1.0=0.61106598, rnn_1step_CC_maskV_-1.0=0.78505635, rnn_1step_MSE_maskV_-1.0=0.38272348, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50212854, val_rnn_1step_R2_maskV_-1.0=0.41027206, val_rnn_1step_CC_maskV_-1.0=0.69564402, learning_rate=0.001\n", + "Epoch 640/707 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3812705, rnn_1step_R2_maskV_-1.0=0.61248034, rnn_1step_CC_maskV_-1.0=0.78601199, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5004099, val_rnn_1step_R2_maskV_-1.0=0.4123404, val_rnn_1step_CC_maskV_-1.0=0.69671887, learning_rate=0.001\n", + "Epoch 707/707 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38010684, rnn_1step_R2_maskV_-1.0=0.61362892, rnn_1step_CC_maskV_-1.0=0.78677213, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49920845, val_rnn_1step_R2_maskV_-1.0=0.4137696, val_rnn_1step_CC_maskV_-1.0=0.69738823, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:11:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 65.09s\n", + "\u001b[32m2025-05-30 11:11:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:11:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 127 (stopped at 142 epochs).\n", + "\u001b[32m2025-05-30 11:11:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/143 - loss=rnn_1_1step_loss=1.0015875, rnn_1_1step_R2_maskV_-1.0=-0.014052421, rnn_1_1step_CC_maskV_-1.0=0.010073047, rnn_1_1step_MSE_maskV_-1.0=1.0015876, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91950387, val_rnn_1_1step_R2_maskV_-1.0=-0.060893118, val_rnn_1_1step_CC_maskV_-1.0=0.1324247, learning_rate=0.001\n", + "Epoch 16/143 - loss=rnn_1_1step_loss=0.70115584, rnn_1_1step_R2_maskV_-1.0=0.28959662, rnn_1_1step_CC_maskV_-1.0=0.54896057, rnn_1_1step_MSE_maskV_-1.0=0.70115578, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.69104463, val_rnn_1_1step_R2_maskV_-1.0=0.19151424, val_rnn_1_1step_CC_maskV_-1.0=0.51906192, learning_rate=0.001\n", + "Epoch 31/143 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.54851109, rnn_1_1step_R2_maskV_-1.0=0.44271052, rnn_1_1step_CC_maskV_-1.0=0.67157072, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60720062, val_rnn_1_1step_R2_maskV_-1.0=0.29178602, val_rnn_1_1step_CC_maskV_-1.0=0.602799, learning_rate=0.001\n", + "Epoch 46/143 - loss=rnn_1_1step_loss=0.48551574, rnn_1_1step_R2_maskV_-1.0=0.50718069, rnn_1_1step_CC_maskV_-1.0=0.71731472, rnn_1_1step_MSE_maskV_-1.0=0.48551577, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57557541, val_rnn_1_1step_R2_maskV_-1.0=0.32665259, val_rnn_1_1step_CC_maskV_-1.0=0.63171101, learning_rate=0.001\n", + "Epoch 61/143 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.45188105, rnn_1_1step_R2_maskV_-1.0=0.54168892, rnn_1_1step_CC_maskV_-1.0=0.74045002, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55156928, val_rnn_1_1step_R2_maskV_-1.0=0.35182458, val_rnn_1_1step_CC_maskV_-1.0=0.65063512, learning_rate=0.001\n", + "Epoch 76/143 - loss=rnn_1_1step_loss=0.42662215, rnn_1_1step_R2_maskV_-1.0=0.56758392, rnn_1_1step_CC_maskV_-1.0=0.75687009, rnn_1_1step_MSE_maskV_-1.0=0.42662212, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52587718, val_rnn_1_1step_R2_maskV_-1.0=0.38137138, val_rnn_1_1step_CC_maskV_-1.0=0.67218888, learning_rate=0.001\n", + "Epoch 91/143 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.4133749, rnn_1_1step_R2_maskV_-1.0=0.58103728, rnn_1_1step_CC_maskV_-1.0=0.76540112, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51401204, val_rnn_1_1step_R2_maskV_-1.0=0.39498675, val_rnn_1_1step_CC_maskV_-1.0=0.68245542, learning_rate=0.001\n", + "Epoch 106/143 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40575895, rnn_1_1step_R2_maskV_-1.0=0.58861732, rnn_1_1step_CC_maskV_-1.0=0.77029288, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50953728, val_rnn_1_1step_R2_maskV_-1.0=0.40036982, val_rnn_1_1step_CC_maskV_-1.0=0.68682086, learning_rate=0.001\n", + "Epoch 121/143 - loss=rnn_1_1step_loss=0.40103483, rnn_1_1step_R2_maskV_-1.0=0.59329581, rnn_1_1step_CC_maskV_-1.0=0.77330619, rnn_1_1step_MSE_maskV_-1.0=0.4010348, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50815886, val_rnn_1_1step_R2_maskV_-1.0=0.40216833, val_rnn_1_1step_CC_maskV_-1.0=0.68866771, learning_rate=0.001\n", + "Epoch 136/143 - loss=rnn_1_1step_loss=0.39820018, rnn_1_1step_R2_maskV_-1.0=0.59609658, rnn_1_1step_CC_maskV_-1.0=0.77510577, rnn_1_1step_MSE_maskV_-1.0=0.39820021, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50820571, val_rnn_1_1step_R2_maskV_-1.0=0.40224242, val_rnn_1_1step_CC_maskV_-1.0=0.68925959, learning_rate=0.001\n", + "Epoch 143/143 - loss=rnn_1_1step_loss=0.39727211, rnn_1_1step_R2_maskV_-1.0=0.59701264, rnn_1_1step_CC_maskV_-1.0=0.77569401, rnn_1_1step_MSE_maskV_-1.0=0.39727208, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50835925, val_rnn_1_1step_R2_maskV_-1.0=0.40210482, val_rnn_1_1step_CC_maskV_-1.0=0.68937296, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:11:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.82s\n", + "\u001b[32m2025-05-30 11:11:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.49913445)\n", + "\u001b[32m2025-05-30 11:11:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.341, R2_maskV_-1.0=0.659, CC_maskV_-1.0=0.812\n", + "\u001b[32m2025-05-30 11:11:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.473, R2_maskV_-1.0=0.455, CC_maskV_-1.0=0.721\n", + "\u001b[32m2025-05-30 11:11:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:11:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:12:01\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 147 (stopped at 162 epochs).\n", + "\u001b[32m2025-05-30 11:12:01\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/163 - loss=54.24398, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0086845495, MSE_maskV_-1.0=54.082649, val_loss=5.3621221, val_CC_maskV_-1.0=0.0042783655, val_MSE_maskV_-1.0=5.3540621, learning_rate=0.001\n", + "Epoch 18/163 - loss=0.98519975, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.22950955, MSE_maskV_-1.0=0.98546642, val_loss=1.0137538, val_CC_maskV_-1.0=0.23163027, val_MSE_maskV_-1.0=1.0113391, learning_rate=0.001\n", + "Epoch 35/163 - loss=0.87061852, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36459646, MSE_maskV_-1.0=0.87027264, val_loss=0.92286497, val_CC_maskV_-1.0=0.34472477, val_MSE_maskV_-1.0=0.92254984, learning_rate=0.001\n", + "Epoch 52/163 - loss=0.82559311, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41922805, MSE_maskV_-1.0=0.82714307, val_loss=0.87703168, val_CC_maskV_-1.0=0.39965507, val_MSE_maskV_-1.0=0.8749097, learning_rate=0.001\n", + "Epoch 69/163 - loss=0.80476791, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44298816, MSE_maskV_-1.0=0.80423826, val_loss=0.84711039, val_CC_maskV_-1.0=0.43387777, val_MSE_maskV_-1.0=0.84572685, learning_rate=0.001\n", + "Epoch 86/163 - loss=0.7915082, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45794913, MSE_maskV_-1.0=0.79079694, val_loss=0.8443433, val_CC_maskV_-1.0=0.43772474, val_MSE_maskV_-1.0=0.84330308, learning_rate=0.001\n", + "Epoch 103/163 - loss=0.78356832, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46655163, MSE_maskV_-1.0=0.78368145, val_loss=0.83020407, val_CC_maskV_-1.0=0.45262355, val_MSE_maskV_-1.0=0.82893807, learning_rate=0.001\n", + "Epoch 120/163 - loss=0.77736616, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47279412, MSE_maskV_-1.0=0.77724218, val_loss=0.82063514, val_CC_maskV_-1.0=0.46359947, val_MSE_maskV_-1.0=0.81906998, learning_rate=0.001\n", + "Epoch 137/163 - loss=0.77196187, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47877151, MSE_maskV_-1.0=0.7715444, val_loss=0.81851512, val_CC_maskV_-1.0=0.464551, val_MSE_maskV_-1.0=0.8171249, learning_rate=0.001\n", + "Epoch 154/163 - loss=0.76739526, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4829129, MSE_maskV_-1.0=0.76723105, val_loss=0.81358802, val_CC_maskV_-1.0=0.47051015, val_MSE_maskV_-1.0=0.8119114, learning_rate=0.001\n", + "Epoch 163/163 - loss=0.76705974, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48427582, MSE_maskV_-1.0=0.76700211, val_loss=0.81331038, val_CC_maskV_-1.0=0.47003731, val_MSE_maskV_-1.0=0.81219858, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:12:01\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 40.55s\n", + "\u001b[32m2025-05-30 11:12:01\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:12:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 147 (stopped at 162 epochs).\n", + "\u001b[32m2025-05-30 11:12:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/163 - loss=41.577797, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.009060774, MSE_maskV_-1.0=41.454304, val_loss=4.4589968, val_CC_maskV_-1.0=0.0028002025, val_MSE_maskV_-1.0=4.4277258, learning_rate=0.001\n", + "Epoch 18/163 - loss=0.98612452, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.2339257, MSE_maskV_-1.0=0.98640072, val_loss=1.0338843, val_CC_maskV_-1.0=0.21489167, val_MSE_maskV_-1.0=1.0302222, learning_rate=0.001\n", + "Epoch 35/163 - loss=0.87128639, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36454707, MSE_maskV_-1.0=0.87083668, val_loss=0.92657191, val_CC_maskV_-1.0=0.34086037, val_MSE_maskV_-1.0=0.92519033, learning_rate=0.001\n", + "Epoch 52/163 - loss=0.8268432, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4182553, MSE_maskV_-1.0=0.82839477, val_loss=0.87760609, val_CC_maskV_-1.0=0.39978099, val_MSE_maskV_-1.0=0.87486237, learning_rate=0.001\n", + "Epoch 69/163 - loss=0.80702502, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44111413, MSE_maskV_-1.0=0.80643749, val_loss=0.85026217, val_CC_maskV_-1.0=0.43157205, val_MSE_maskV_-1.0=0.8482815, learning_rate=0.001\n", + "Epoch 86/163 - loss=0.79421979, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45538479, MSE_maskV_-1.0=0.79347634, val_loss=0.84753937, val_CC_maskV_-1.0=0.43596122, val_MSE_maskV_-1.0=0.84588683, learning_rate=0.001\n", + "Epoch 103/163 - loss=0.78661257, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46392575, MSE_maskV_-1.0=0.78666323, val_loss=0.83348358, val_CC_maskV_-1.0=0.45081508, val_MSE_maskV_-1.0=0.83162165, learning_rate=0.001\n", + "Epoch 120/163 - loss=0.78034747, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47017458, MSE_maskV_-1.0=0.78021985, val_loss=0.82354856, val_CC_maskV_-1.0=0.46232033, val_MSE_maskV_-1.0=0.82149267, learning_rate=0.001\n", + "Epoch 137/163 - loss=0.77475971, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4762539, MSE_maskV_-1.0=0.77435821, val_loss=0.82197714, val_CC_maskV_-1.0=0.46247032, val_MSE_maskV_-1.0=0.82017773, learning_rate=0.001\n", + "Epoch 154/163 - loss=0.7698372, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48076335, MSE_maskV_-1.0=0.76968241, val_loss=0.81656021, val_CC_maskV_-1.0=0.46896359, val_MSE_maskV_-1.0=0.81452209, learning_rate=0.001\n", + "Epoch 163/163 - loss=0.7692697, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4823615, MSE_maskV_-1.0=0.76915663, val_loss=0.81574863, val_CC_maskV_-1.0=0.46907279, val_MSE_maskV_-1.0=0.81424427, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:12:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 40.41s\n", + "\u001b[32m2025-05-30 11:12:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.80806166)\n", + "\u001b[32m2025-05-30 11:12:41\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 782us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:12:41\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.76, R2_maskV_-1.0=0.24, CC_maskV_-1.0=0.491\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 756us/step\n", + "51/51 [==============================] - 0s 788us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:12:42\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_ErSV16\" (1/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:12:42\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_A1HL64U_ErSV16\" (2/16)\n", + "\u001b[32m2025-05-30 11:12:42\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_A1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:12:42\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:12:42\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:12:42\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:12:42\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:12:42\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:12:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:12:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 117 (stopped at 132 epochs).\n", + "\u001b[32m2025-05-30 11:12:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/133 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0022308, rnn_1step_R2_maskV_-1.0=-0.014734991, rnn_1step_CC_maskV_-1.0=-0.0055518625, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92068392, val_rnn_1step_R2_maskV_-1.0=-0.06208539, val_rnn_1step_CC_maskV_-1.0=0.09818469, learning_rate=0.001\n", + "Epoch 15/133 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.74816924, rnn_1step_R2_maskV_-1.0=0.24208903, rnn_1step_CC_maskV_-1.0=0.51209909, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.71595478, val_rnn_1step_R2_maskV_-1.0=0.17102024, val_rnn_1step_CC_maskV_-1.0=0.48698097, learning_rate=0.001\n", + "Epoch 29/133 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.55587554, rnn_1step_R2_maskV_-1.0=0.43478191, rnn_1step_CC_maskV_-1.0=0.66590881, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61455297, val_rnn_1step_R2_maskV_-1.0=0.28513753, val_rnn_1step_CC_maskV_-1.0=0.58939809, learning_rate=0.001\n", + "Epoch 43/133 - loss=rnn_1step_loss=0.49812412, rnn_1step_R2_maskV_-1.0=0.49325383, rnn_1step_CC_maskV_-1.0=0.70786875, rnn_1step_MSE_maskV_-1.0=0.49812415, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59789026, val_rnn_1step_R2_maskV_-1.0=0.30527788, val_rnn_1step_CC_maskV_-1.0=0.61149812, learning_rate=0.001\n", + "Epoch 57/133 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.45592538, rnn_1step_R2_maskV_-1.0=0.53609622, rnn_1step_CC_maskV_-1.0=0.73763001, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56623709, val_rnn_1step_R2_maskV_-1.0=0.34315452, val_rnn_1step_CC_maskV_-1.0=0.63643539, learning_rate=0.001\n", + "Epoch 71/133 - loss=rnn_1step_loss=0.40921983, rnn_1step_R2_maskV_-1.0=0.5835191, rnn_1step_CC_maskV_-1.0=0.7678684, rnn_1step_MSE_maskV_-1.0=0.40921986, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5337674, val_rnn_1step_R2_maskV_-1.0=0.37940741, val_rnn_1step_CC_maskV_-1.0=0.65965468, learning_rate=0.001\n", + "Epoch 85/133 - loss=rnn_1step_loss=0.37915465, rnn_1step_R2_maskV_-1.0=0.61416, rnn_1step_CC_maskV_-1.0=0.78706396, rnn_1step_MSE_maskV_-1.0=0.37915462, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5386278, val_rnn_1step_R2_maskV_-1.0=0.37175667, val_rnn_1step_CC_maskV_-1.0=0.65970331, learning_rate=0.001\n", + "Epoch 99/133 - loss=rnn_1step_loss=0.36399141, rnn_1step_R2_maskV_-1.0=0.62984979, rnn_1step_CC_maskV_-1.0=0.79649431, rnn_1step_MSE_maskV_-1.0=0.36399144, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51143718, val_rnn_1step_R2_maskV_-1.0=0.40484148, val_rnn_1step_CC_maskV_-1.0=0.67946637, learning_rate=0.001\n", + "Epoch 113/133 - loss=rnn_1step_loss=0.34942341, rnn_1step_R2_maskV_-1.0=0.64506578, rnn_1step_CC_maskV_-1.0=0.80657196, rnn_1step_MSE_maskV_-1.0=0.34942344, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49364749, val_rnn_1step_R2_maskV_-1.0=0.42532796, val_rnn_1step_CC_maskV_-1.0=0.68677223, learning_rate=0.001\n", + "Epoch 127/133 - loss=rnn_1step_loss=0.3437103, rnn_1step_R2_maskV_-1.0=0.65068626, rnn_1step_CC_maskV_-1.0=0.80955261, rnn_1step_MSE_maskV_-1.0=0.34371033, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5001502, val_rnn_1step_R2_maskV_-1.0=0.41824484, val_rnn_1step_CC_maskV_-1.0=0.68751687, learning_rate=0.001\n", + "Epoch 133/133 - loss=rnn_1step_loss=0.33958873, rnn_1step_R2_maskV_-1.0=0.65490329, rnn_1step_CC_maskV_-1.0=0.81254208, rnn_1step_MSE_maskV_-1.0=0.33958867, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50171286, val_rnn_1step_R2_maskV_-1.0=0.41568565, val_rnn_1step_CC_maskV_-1.0=0.68512464, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:12:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 16.71s\n", + "\u001b[32m2025-05-30 11:12:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:13:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 82 (stopped at 97 epochs).\n", + "\u001b[32m2025-05-30 11:13:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/98 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.99757475, rnn_1_1step_R2_maskV_-1.0=-0.010181677, rnn_1_1step_CC_maskV_-1.0=0.098985285, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91747934, val_rnn_1_1step_R2_maskV_-1.0=-0.057642668, val_rnn_1_1step_CC_maskV_-1.0=0.15590207, learning_rate=0.001\n", + "Epoch 11/98 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.8412028, rnn_1_1step_R2_maskV_-1.0=0.14674014, rnn_1_1step_CC_maskV_-1.0=0.40276802, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.80159187, val_rnn_1_1step_R2_maskV_-1.0=0.068197459, val_rnn_1_1step_CC_maskV_-1.0=0.37053964, learning_rate=0.001\n", + "Epoch 21/98 - loss=rnn_1_1step_loss=0.71639854, rnn_1_1step_R2_maskV_-1.0=0.27481601, rnn_1_1step_CC_maskV_-1.0=0.53693271, rnn_1_1step_MSE_maskV_-1.0=0.7163986, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.69869894, val_rnn_1_1step_R2_maskV_-1.0=0.18537493, val_rnn_1_1step_CC_maskV_-1.0=0.49089742, learning_rate=0.001\n", + "Epoch 31/98 - loss=rnn_1_1step_loss=0.60984808, rnn_1_1step_R2_maskV_-1.0=0.38158727, rnn_1_1step_CC_maskV_-1.0=0.62438321, rnn_1_1step_MSE_maskV_-1.0=0.60984814, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65729064, val_rnn_1_1step_R2_maskV_-1.0=0.23541233, val_rnn_1_1step_CC_maskV_-1.0=0.5467428, learning_rate=0.001\n", + "Epoch 41/98 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.50444633, rnn_1_1step_R2_maskV_-1.0=0.48821157, rnn_1_1step_CC_maskV_-1.0=0.70339936, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59381074, val_rnn_1_1step_R2_maskV_-1.0=0.30495346, val_rnn_1_1step_CC_maskV_-1.0=0.61707157, learning_rate=0.001\n", + "Epoch 51/98 - loss=rnn_1_1step_loss=0.47362098, rnn_1_1step_R2_maskV_-1.0=0.52027762, rnn_1_1step_CC_maskV_-1.0=0.72422755, rnn_1_1step_MSE_maskV_-1.0=0.47362101, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56259531, val_rnn_1_1step_R2_maskV_-1.0=0.3384783, val_rnn_1_1step_CC_maskV_-1.0=0.64485532, learning_rate=0.001\n", + "Epoch 61/98 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.45313191, rnn_1_1step_R2_maskV_-1.0=0.54114258, rnn_1_1step_CC_maskV_-1.0=0.739259, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54772729, val_rnn_1_1step_R2_maskV_-1.0=0.35426253, val_rnn_1_1step_CC_maskV_-1.0=0.6523813, learning_rate=0.001\n", + "Epoch 71/98 - loss=rnn_1_1step_loss=0.44132438, rnn_1_1step_R2_maskV_-1.0=0.55291325, rnn_1_1step_CC_maskV_-1.0=0.74651903, rnn_1_1step_MSE_maskV_-1.0=0.44132444, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55170542, val_rnn_1_1step_R2_maskV_-1.0=0.34975976, val_rnn_1_1step_CC_maskV_-1.0=0.6537807, learning_rate=0.001\n", + "Epoch 81/98 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.43141675, rnn_1_1step_R2_maskV_-1.0=0.56286716, rnn_1_1step_CC_maskV_-1.0=0.75302058, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5615198, val_rnn_1_1step_R2_maskV_-1.0=0.33887917, val_rnn_1_1step_CC_maskV_-1.0=0.65258282, learning_rate=0.001\n", + "Epoch 91/98 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42101014, rnn_1_1step_R2_maskV_-1.0=0.57339525, rnn_1_1step_CC_maskV_-1.0=0.75997078, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53853709, val_rnn_1_1step_R2_maskV_-1.0=0.36599821, val_rnn_1_1step_CC_maskV_-1.0=0.66436541, learning_rate=0.001\n", + "Epoch 98/98 - loss=rnn_1_1step_loss=0.41699228, rnn_1_1step_R2_maskV_-1.0=0.57732636, rnn_1_1step_CC_maskV_-1.0=0.7624312, rnn_1_1step_MSE_maskV_-1.0=0.41699225, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53297681, val_rnn_1_1step_R2_maskV_-1.0=0.37266111, val_rnn_1_1step_CC_maskV_-1.0=0.66674948, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:13:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.57s\n", + "\u001b[32m2025-05-30 11:13:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.488646)\n", + "\u001b[32m2025-05-30 11:13:13\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.323, R2_maskV_-1.0=0.676, CC_maskV_-1.0=0.823\n", + "\u001b[32m2025-05-30 11:13:13\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.47, R2_maskV_-1.0=0.466, CC_maskV_-1.0=0.711\n", + "\u001b[32m2025-05-30 11:13:13\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:13:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:13:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 164 (stopped at 179 epochs).\n", + "\u001b[32m2025-05-30 11:13:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/180 - loss=2.2877507, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.040739685, MSE_maskV_-1.0=2.2846069, val_loss=1.213398, val_CC_maskV_-1.0=0.094668359, val_MSE_maskV_-1.0=1.2147498, learning_rate=0.001\n", + "Epoch 19/180 - loss=0.79351687, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45535401, MSE_maskV_-1.0=0.79315501, val_loss=0.83274883, val_CC_maskV_-1.0=0.44671515, val_MSE_maskV_-1.0=0.83044726, learning_rate=0.001\n", + "Epoch 37/180 - loss=0.76448864, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48635998, MSE_maskV_-1.0=0.76471937, val_loss=0.8018173, val_CC_maskV_-1.0=0.47964785, val_MSE_maskV_-1.0=0.79986805, learning_rate=0.001\n", + "Epoch 55/180 - loss=0.75046915, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50006151, MSE_maskV_-1.0=0.74971223, val_loss=0.78917259, val_CC_maskV_-1.0=0.49115229, val_MSE_maskV_-1.0=0.78773433, learning_rate=0.001\n", + "Epoch 73/180 - loss=0.74279541, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50651383, MSE_maskV_-1.0=0.74317479, val_loss=0.78114605, val_CC_maskV_-1.0=0.49920136, val_MSE_maskV_-1.0=0.77946508, learning_rate=0.001\n", + "Epoch 91/180 - loss=0.73825175, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51205331, MSE_maskV_-1.0=0.73893398, val_loss=0.77433425, val_CC_maskV_-1.0=0.50495374, val_MSE_maskV_-1.0=0.77279073, learning_rate=0.001\n", + "Epoch 109/180 - loss=0.73567694, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51381183, MSE_maskV_-1.0=0.73534107, val_loss=0.7722863, val_CC_maskV_-1.0=0.50604403, val_MSE_maskV_-1.0=0.77135265, learning_rate=0.001\n", + "Epoch 127/180 - loss=0.73417616, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51448733, MSE_maskV_-1.0=0.73543864, val_loss=0.77234572, val_CC_maskV_-1.0=0.50695533, val_MSE_maskV_-1.0=0.77085054, learning_rate=0.001\n", + "Epoch 145/180 - loss=0.73293102, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.515517, MSE_maskV_-1.0=0.73357499, val_loss=0.76984012, val_CC_maskV_-1.0=0.5084089, val_MSE_maskV_-1.0=0.76841861, learning_rate=0.001\n", + "Epoch 163/180 - loss=0.73230016, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51749027, MSE_maskV_-1.0=0.73206037, val_loss=0.76796305, val_CC_maskV_-1.0=0.51018649, val_MSE_maskV_-1.0=0.76681548, learning_rate=0.001\n", + "Epoch 180/180 - loss=0.73141623, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51766908, MSE_maskV_-1.0=0.73112351, val_loss=0.76821262, val_CC_maskV_-1.0=0.5095619, val_MSE_maskV_-1.0=0.76712656, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:13:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 44.91s\n", + "\u001b[32m2025-05-30 11:13:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:14:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 164 (stopped at 179 epochs).\n", + "\u001b[32m2025-05-30 11:14:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/180 - loss=2.0356517, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.079453319, MSE_maskV_-1.0=2.0329471, val_loss=1.141196, val_CC_maskV_-1.0=0.15872554, val_MSE_maskV_-1.0=1.1366518, learning_rate=0.001\n", + "Epoch 19/180 - loss=0.78923053, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46019369, MSE_maskV_-1.0=0.78889638, val_loss=0.82795411, val_CC_maskV_-1.0=0.45226997, val_MSE_maskV_-1.0=0.82567996, learning_rate=0.001\n", + "Epoch 37/180 - loss=0.76243752, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4884465, MSE_maskV_-1.0=0.76264805, val_loss=0.79950684, val_CC_maskV_-1.0=0.48212317, val_MSE_maskV_-1.0=0.79761744, learning_rate=0.001\n", + "Epoch 55/180 - loss=0.74944776, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50102699, MSE_maskV_-1.0=0.74869972, val_loss=0.78811419, val_CC_maskV_-1.0=0.49240449, val_MSE_maskV_-1.0=0.78670609, learning_rate=0.001\n", + "Epoch 73/180 - loss=0.74224955, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50700718, MSE_maskV_-1.0=0.74263036, val_loss=0.78043342, val_CC_maskV_-1.0=0.50008357, val_MSE_maskV_-1.0=0.77880263, learning_rate=0.001\n", + "Epoch 91/180 - loss=0.73795182, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51230973, MSE_maskV_-1.0=0.73865014, val_loss=0.77392131, val_CC_maskV_-1.0=0.50551993, val_MSE_maskV_-1.0=0.77240938, learning_rate=0.001\n", + "Epoch 109/180 - loss=0.73550314, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51395124, MSE_maskV_-1.0=0.7351771, val_loss=0.77195638, val_CC_maskV_-1.0=0.5064742, val_MSE_maskV_-1.0=0.77107865, learning_rate=0.001\n", + "Epoch 127/180 - loss=0.73407316, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51457989, MSE_maskV_-1.0=0.73532569, val_loss=0.77208096, val_CC_maskV_-1.0=0.50730693, val_MSE_maskV_-1.0=0.77062696, learning_rate=0.001\n", + "Epoch 145/180 - loss=0.73287201, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51558316, MSE_maskV_-1.0=0.73350769, val_loss=0.76966542, val_CC_maskV_-1.0=0.508672, val_MSE_maskV_-1.0=0.76826704, learning_rate=0.001\n", + "Epoch 163/180 - loss=0.73226267, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51752871, MSE_maskV_-1.0=0.73202282, val_loss=0.76778138, val_CC_maskV_-1.0=0.51040787, val_MSE_maskV_-1.0=0.76667583, learning_rate=0.001\n", + "Epoch 180/180 - loss=0.73139215, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51769787, MSE_maskV_-1.0=0.73109996, val_loss=0.76807356, val_CC_maskV_-1.0=0.50973672, val_MSE_maskV_-1.0=0.76702589, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:14:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 44.55s\n", + "\u001b[32m2025-05-30 11:14:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.76639277)\n", + "\u001b[32m2025-05-30 11:14:43\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 763us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:14:43\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.731, R2_maskV_-1.0=0.269, CC_maskV_-1.0=0.519\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 722us/step\n", + "51/51 [==============================] - 0s 801us/step\n", + "84/84 [==============================] - 0s 733us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:14:44\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_A1HL64U_ErSV16\" (2/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_A1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:14:44\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_K1HL64U_ErSV16\" (3/16)\n", + "\u001b[32m2025-05-30 11:14:44\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_K1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:14:44\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:14:44\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:14:44\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:14:44\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:14:44\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:14:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:14:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 70 (stopped at 85 epochs).\n", + "\u001b[32m2025-05-30 11:14:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/86 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0008332, rnn_1step_R2_maskV_-1.0=-0.013481978, rnn_1step_CC_maskV_-1.0=0.12126799, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92159986, val_rnn_1step_R2_maskV_-1.0=-0.062864542, val_rnn_1step_CC_maskV_-1.0=0.26544097, learning_rate=0.001\n", + "Epoch 10/86 - loss=rnn_1step_loss=0.84911543, rnn_1step_R2_maskV_-1.0=0.13828024, rnn_1step_CC_maskV_-1.0=0.39317703, rnn_1step_MSE_maskV_-1.0=0.84911549, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.7978403, val_rnn_1step_R2_maskV_-1.0=0.068001419, val_rnn_1step_CC_maskV_-1.0=0.37815541, learning_rate=0.001\n", + "Epoch 19/86 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.65952712, rnn_1step_R2_maskV_-1.0=0.32907474, rnn_1step_CC_maskV_-1.0=0.58522916, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.67635942, val_rnn_1step_R2_maskV_-1.0=0.20816919, val_rnn_1step_CC_maskV_-1.0=0.53724754, learning_rate=0.001\n", + "Epoch 28/86 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.54463524, rnn_1step_R2_maskV_-1.0=0.44505286, rnn_1step_CC_maskV_-1.0=0.67574126, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60896605, val_rnn_1step_R2_maskV_-1.0=0.28935611, val_rnn_1step_CC_maskV_-1.0=0.59703153, learning_rate=0.001\n", + "Epoch 37/86 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.45316076, rnn_1step_R2_maskV_-1.0=0.53870869, rnn_1step_CC_maskV_-1.0=0.73948216, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56772739, val_rnn_1step_R2_maskV_-1.0=0.33846691, val_rnn_1step_CC_maskV_-1.0=0.63967079, learning_rate=0.001\n", + "Epoch 46/86 - loss=rnn_1step_loss=0.38097253, rnn_1step_R2_maskV_-1.0=0.61293697, rnn_1step_CC_maskV_-1.0=0.78702605, rnn_1step_MSE_maskV_-1.0=0.3809725, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50609142, val_rnn_1step_R2_maskV_-1.0=0.40815407, val_rnn_1step_CC_maskV_-1.0=0.68495989, learning_rate=0.001\n", + "Epoch 55/86 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34049806, rnn_1step_R2_maskV_-1.0=0.65439677, rnn_1step_CC_maskV_-1.0=0.81222767, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48832512, val_rnn_1step_R2_maskV_-1.0=0.42904842, val_rnn_1step_CC_maskV_-1.0=0.69916517, learning_rate=0.001\n", + "Epoch 64/86 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30365756, rnn_1step_R2_maskV_-1.0=0.69219649, rnn_1step_CC_maskV_-1.0=0.83445948, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47472247, val_rnn_1step_R2_maskV_-1.0=0.44420952, val_rnn_1step_CC_maskV_-1.0=0.71262556, learning_rate=0.001\n", + "Epoch 73/86 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27378044, rnn_1step_R2_maskV_-1.0=0.72286719, rnn_1step_CC_maskV_-1.0=0.85198992, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47149077, val_rnn_1step_R2_maskV_-1.0=0.44746047, val_rnn_1step_CC_maskV_-1.0=0.72021568, learning_rate=0.001\n", + "Epoch 82/86 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.25484037, rnn_1step_R2_maskV_-1.0=0.74223483, rnn_1step_CC_maskV_-1.0=0.862872, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47767463, val_rnn_1step_R2_maskV_-1.0=0.44024426, val_rnn_1step_CC_maskV_-1.0=0.72050858, learning_rate=0.001\n", + "Epoch 86/86 - loss=rnn_1step_loss=0.24857922, rnn_1step_R2_maskV_-1.0=0.74863374, rnn_1step_CC_maskV_-1.0=0.86648226, rnn_1step_MSE_maskV_-1.0=0.24857925, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48003063, val_rnn_1step_R2_maskV_-1.0=0.43739283, val_rnn_1step_CC_maskV_-1.0=0.72016877, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:14:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.20s\n", + "\u001b[32m2025-05-30 11:14:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:15:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 61 (stopped at 76 epochs).\n", + "\u001b[32m2025-05-30 11:15:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/77 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0010724, rnn_1_1step_R2_maskV_-1.0=-0.013735116, rnn_1_1step_CC_maskV_-1.0=0.064332649, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92256624, val_rnn_1_1step_R2_maskV_-1.0=-0.063915953, val_rnn_1_1step_CC_maskV_-1.0=0.17043015, learning_rate=0.001\n", + "Epoch 9/77 - loss=rnn_1_1step_loss=0.89489561, rnn_1_1step_R2_maskV_-1.0=0.093244106, rnn_1_1step_CC_maskV_-1.0=0.38914248, rnn_1_1step_MSE_maskV_-1.0=0.89489567, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.82205677, val_rnn_1_1step_R2_maskV_-1.0=0.052015007, val_rnn_1_1step_CC_maskV_-1.0=0.36215758, learning_rate=0.001\n", + "Epoch 17/77 - loss=rnn_1_1step_loss=0.67017031, rnn_1_1step_R2_maskV_-1.0=0.31736416, rnn_1_1step_CC_maskV_-1.0=0.57744467, rnn_1_1step_MSE_maskV_-1.0=0.67017037, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.70001286, val_rnn_1_1step_R2_maskV_-1.0=0.18431292, val_rnn_1_1step_CC_maskV_-1.0=0.51260126, learning_rate=0.001\n", + "Epoch 25/77 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.54229569, rnn_1_1step_R2_maskV_-1.0=0.44763374, rnn_1_1step_CC_maskV_-1.0=0.67803836, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59376621, val_rnn_1_1step_R2_maskV_-1.0=0.30708569, val_rnn_1_1step_CC_maskV_-1.0=0.61015689, learning_rate=0.001\n", + "Epoch 33/77 - loss=rnn_1_1step_loss=0.46173111, rnn_1_1step_R2_maskV_-1.0=0.52983606, rnn_1_1step_CC_maskV_-1.0=0.73426074, rnn_1_1step_MSE_maskV_-1.0=0.46173108, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56064385, val_rnn_1_1step_R2_maskV_-1.0=0.34645748, val_rnn_1_1step_CC_maskV_-1.0=0.64473593, learning_rate=0.001\n", + "Epoch 41/77 - loss=rnn_1_1step_loss=0.38277566, rnn_1_1step_R2_maskV_-1.0=0.61123931, rnn_1_1step_CC_maskV_-1.0=0.78633374, rnn_1_1step_MSE_maskV_-1.0=0.38277569, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51256138, val_rnn_1_1step_R2_maskV_-1.0=0.40173447, val_rnn_1_1step_CC_maskV_-1.0=0.68352908, learning_rate=0.001\n", + "Epoch 49/77 - loss=rnn_1_1step_loss=0.33094242, rnn_1_1step_R2_maskV_-1.0=0.66466719, rnn_1_1step_CC_maskV_-1.0=0.8183443, rnn_1_1step_MSE_maskV_-1.0=0.33094239, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48436841, val_rnn_1_1step_R2_maskV_-1.0=0.43354765, val_rnn_1_1step_CC_maskV_-1.0=0.70554852, learning_rate=0.001\n", + "Epoch 57/77 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30161816, rnn_1_1step_R2_maskV_-1.0=0.69486541, rnn_1_1step_CC_maskV_-1.0=0.8359623, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48176599, val_rnn_1_1step_R2_maskV_-1.0=0.43611443, val_rnn_1_1step_CC_maskV_-1.0=0.71192974, learning_rate=0.001\n", + "Epoch 65/77 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.28251165, rnn_1_1step_R2_maskV_-1.0=0.71443343, rnn_1_1step_CC_maskV_-1.0=0.84718442, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48248515, val_rnn_1_1step_R2_maskV_-1.0=0.43520951, val_rnn_1_1step_CC_maskV_-1.0=0.71454507, learning_rate=0.001\n", + "Epoch 73/77 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.26832858, rnn_1_1step_R2_maskV_-1.0=0.72886461, rnn_1_1step_CC_maskV_-1.0=0.85545421, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48638868, val_rnn_1_1step_R2_maskV_-1.0=0.43067622, val_rnn_1_1step_CC_maskV_-1.0=0.71452117, learning_rate=0.001\n", + "Epoch 77/77 - loss=rnn_1_1step_loss=0.2621991, rnn_1_1step_R2_maskV_-1.0=0.7350775, rnn_1_1step_CC_maskV_-1.0=0.85899621, rnn_1_1step_MSE_maskV_-1.0=0.26219907, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48861432, val_rnn_1_1step_R2_maskV_-1.0=0.4280628, val_rnn_1_1step_CC_maskV_-1.0=0.71419621, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:15:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 9.10s\n", + "\u001b[32m2025-05-30 11:15:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.47072074)\n", + "\u001b[32m2025-05-30 11:15:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.249, R2_maskV_-1.0=0.751, CC_maskV_-1.0=0.867\n", + "\u001b[32m2025-05-30 11:15:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.432, R2_maskV_-1.0=0.505, CC_maskV_-1.0=0.749\n", + "\u001b[32m2025-05-30 11:15:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:15:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:16:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 428 (stopped at 443 epochs).\n", + "\u001b[32m2025-05-30 11:16:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/444 - loss=1.6456838, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.031525761, MSE_maskV_-1.0=1.6440088, val_loss=1.0603133, val_CC_maskV_-1.0=0.1177016, val_MSE_maskV_-1.0=1.0578438, learning_rate=0.001\n", + "Epoch 46/444 - loss=0.89049172, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3391521, MSE_maskV_-1.0=0.8906281, val_loss=0.92708552, val_CC_maskV_-1.0=0.33488947, val_MSE_maskV_-1.0=0.92479509, learning_rate=0.001\n", + "Epoch 91/444 - loss=0.86320925, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37856323, MSE_maskV_-1.0=0.86445904, val_loss=0.89864081, val_CC_maskV_-1.0=0.3738524, val_MSE_maskV_-1.0=0.89559209, learning_rate=0.001\n", + "Epoch 136/444 - loss=0.84780258, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39675257, MSE_maskV_-1.0=0.84839165, val_loss=0.88303298, val_CC_maskV_-1.0=0.39141744, val_MSE_maskV_-1.0=0.88038117, learning_rate=0.001\n", + "Epoch 181/444 - loss=0.83774507, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40784723, MSE_maskV_-1.0=0.83771229, val_loss=0.87168372, val_CC_maskV_-1.0=0.40373245, val_MSE_maskV_-1.0=0.86908996, learning_rate=0.001\n", + "Epoch 226/444 - loss=0.83041173, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4162356, MSE_maskV_-1.0=0.83015019, val_loss=0.86532521, val_CC_maskV_-1.0=0.40915385, val_MSE_maskV_-1.0=0.86247087, learning_rate=0.001\n", + "Epoch 271/444 - loss=0.8246457, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42261764, MSE_maskV_-1.0=0.82431418, val_loss=0.86095154, val_CC_maskV_-1.0=0.4141793, val_MSE_maskV_-1.0=0.85814452, learning_rate=0.001\n", + "Epoch 316/444 - loss=0.82008499, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42768905, MSE_maskV_-1.0=0.81970435, val_loss=0.85479176, val_CC_maskV_-1.0=0.42045066, val_MSE_maskV_-1.0=0.85257357, learning_rate=0.001\n", + "Epoch 361/444 - loss=0.81656551, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43157282, MSE_maskV_-1.0=0.81586379, val_loss=0.84931731, val_CC_maskV_-1.0=0.42621997, val_MSE_maskV_-1.0=0.84698397, learning_rate=0.001\n", + "Epoch 406/444 - loss=0.8132531, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43524307, MSE_maskV_-1.0=0.81331038, val_loss=0.84692276, val_CC_maskV_-1.0=0.42848173, val_MSE_maskV_-1.0=0.84429151, learning_rate=0.001\n", + "Epoch 444/444 - loss=0.8111766, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43671504, MSE_maskV_-1.0=0.81331944, val_loss=0.84470791, val_CC_maskV_-1.0=0.43020985, val_MSE_maskV_-1.0=0.84208697, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:16:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 108.50s\n", + "\u001b[32m2025-05-30 11:16:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:18:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 428 (stopped at 443 epochs).\n", + "\u001b[32m2025-05-30 11:18:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/444 - loss=1.6136378, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.048179742, MSE_maskV_-1.0=1.6120396, val_loss=1.0743259, val_CC_maskV_-1.0=0.10087583, val_MSE_maskV_-1.0=1.0720701, learning_rate=0.001\n", + "Epoch 46/444 - loss=0.8922925, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3364965, MSE_maskV_-1.0=0.8924225, val_loss=0.92920357, val_CC_maskV_-1.0=0.33111054, val_MSE_maskV_-1.0=0.92720211, learning_rate=0.001\n", + "Epoch 91/444 - loss=0.86346054, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37872219, MSE_maskV_-1.0=0.86469471, val_loss=0.89891952, val_CC_maskV_-1.0=0.3734709, val_MSE_maskV_-1.0=0.89606333, learning_rate=0.001\n", + "Epoch 136/444 - loss=0.8474285, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39767569, MSE_maskV_-1.0=0.84798324, val_loss=0.88246596, val_CC_maskV_-1.0=0.39211306, val_MSE_maskV_-1.0=0.87994951, learning_rate=0.001\n", + "Epoch 181/444 - loss=0.83714598, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40886679, MSE_maskV_-1.0=0.83709711, val_loss=0.87087768, val_CC_maskV_-1.0=0.40457892, val_MSE_maskV_-1.0=0.8684122, learning_rate=0.001\n", + "Epoch 226/444 - loss=0.82973868, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4172442, MSE_maskV_-1.0=0.82947534, val_loss=0.86432457, val_CC_maskV_-1.0=0.41006944, val_MSE_maskV_-1.0=0.86159283, learning_rate=0.001\n", + "Epoch 271/444 - loss=0.82397282, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42353067, MSE_maskV_-1.0=0.82363451, val_loss=0.85992205, val_CC_maskV_-1.0=0.41506204, val_MSE_maskV_-1.0=0.85721499, learning_rate=0.001\n", + "Epoch 316/444 - loss=0.81945485, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42849287, MSE_maskV_-1.0=0.81907636, val_loss=0.85382718, val_CC_maskV_-1.0=0.42121688, val_MSE_maskV_-1.0=0.85171247, learning_rate=0.001\n", + "Epoch 361/444 - loss=0.81598133, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43229249, MSE_maskV_-1.0=0.81527495, val_loss=0.84842467, val_CC_maskV_-1.0=0.42686048, val_MSE_maskV_-1.0=0.84620321, learning_rate=0.001\n", + "Epoch 406/444 - loss=0.81271803, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43585691, MSE_maskV_-1.0=0.81277132, val_loss=0.8460716, val_CC_maskV_-1.0=0.42908111, val_MSE_maskV_-1.0=0.84353173, learning_rate=0.001\n", + "Epoch 444/444 - loss=0.81068558, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43724492, MSE_maskV_-1.0=0.81284374, val_loss=0.84393549, val_CC_maskV_-1.0=0.43070808, val_MSE_maskV_-1.0=0.84140897, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:18:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 107.38s\n", + "\u001b[32m2025-05-30 11:18:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.84363943)\n", + "\u001b[32m2025-05-30 11:18:41\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 704us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:18:41\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.81, R2_maskV_-1.0=0.189, CC_maskV_-1.0=0.438\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 740us/step\n", + "51/51 [==============================] - 0s 709us/step\n", + "84/84 [==============================] - 0s 674us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:18:42\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_K1HL64U_ErSV16\" (3/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_K1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:18:42\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_Cz1HL64U_ErSV16\" (4/16)\n", + "\u001b[32m2025-05-30 11:18:42\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_Cz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:18:42\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:18:42\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:18:42\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:18:42\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:18:42\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:18:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:19:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 288 (stopped at 303 epochs).\n", + "\u001b[32m2025-05-30 11:19:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/304 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0010651, rnn_1step_R2_maskV_-1.0=-0.013721656, rnn_1step_CC_maskV_-1.0=0.064052351, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92125911, val_rnn_1step_R2_maskV_-1.0=-0.062462822, val_rnn_1step_CC_maskV_-1.0=0.25596532, learning_rate=0.001\n", + "Epoch 32/304 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.51875108, rnn_1step_R2_maskV_-1.0=0.47169369, rnn_1step_CC_maskV_-1.0=0.69331563, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60828942, val_rnn_1step_R2_maskV_-1.0=0.29452157, val_rnn_1step_CC_maskV_-1.0=0.60148931, learning_rate=0.001\n", + "Epoch 63/304 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39681184, rnn_1step_R2_maskV_-1.0=0.59595108, rnn_1step_CC_maskV_-1.0=0.77669233, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52541047, val_rnn_1step_R2_maskV_-1.0=0.38585526, val_rnn_1step_CC_maskV_-1.0=0.66876924, learning_rate=0.001\n", + "Epoch 94/304 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35422221, rnn_1step_R2_maskV_-1.0=0.63933206, rnn_1step_CC_maskV_-1.0=0.803289, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49607182, val_rnn_1step_R2_maskV_-1.0=0.41876838, val_rnn_1step_CC_maskV_-1.0=0.69542158, learning_rate=0.001\n", + "Epoch 125/304 - loss=rnn_1step_loss=0.33462048, rnn_1step_R2_maskV_-1.0=0.65942842, rnn_1step_CC_maskV_-1.0=0.81543148, rnn_1step_MSE_maskV_-1.0=0.33462045, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48193583, val_rnn_1step_R2_maskV_-1.0=0.43464065, val_rnn_1step_CC_maskV_-1.0=0.7100926, learning_rate=0.001\n", + "Epoch 156/304 - loss=rnn_1step_loss=0.32500017, rnn_1step_R2_maskV_-1.0=0.6692853, rnn_1step_CC_maskV_-1.0=0.82133567, rnn_1step_MSE_maskV_-1.0=0.32500014, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47771397, val_rnn_1step_R2_maskV_-1.0=0.43968308, val_rnn_1step_CC_maskV_-1.0=0.7154752, learning_rate=0.001\n", + "Epoch 187/304 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31908396, rnn_1step_R2_maskV_-1.0=0.67539865, rnn_1step_CC_maskV_-1.0=0.82493848, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47386909, val_rnn_1step_R2_maskV_-1.0=0.44415256, val_rnn_1step_CC_maskV_-1.0=0.718876, learning_rate=0.001\n", + "Epoch 218/304 - loss=rnn_1step_loss=0.3124198, rnn_1step_R2_maskV_-1.0=0.68213803, rnn_1step_CC_maskV_-1.0=0.8290422, rnn_1step_MSE_maskV_-1.0=0.31241983, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46992755, val_rnn_1step_R2_maskV_-1.0=0.44900355, val_rnn_1step_CC_maskV_-1.0=0.7212857, learning_rate=0.001\n", + "Epoch 249/304 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30778623, rnn_1step_R2_maskV_-1.0=0.68687475, rnn_1step_CC_maskV_-1.0=0.83195257, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46837428, val_rnn_1step_R2_maskV_-1.0=0.45083374, val_rnn_1step_CC_maskV_-1.0=0.72344327, learning_rate=0.001\n", + "Epoch 280/304 - loss=rnn_1step_loss=0.30340219, rnn_1step_R2_maskV_-1.0=0.69132, rnn_1step_CC_maskV_-1.0=0.83448058, rnn_1step_MSE_maskV_-1.0=0.30340216, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46243095, val_rnn_1step_R2_maskV_-1.0=0.45775467, val_rnn_1step_CC_maskV_-1.0=0.72635847, learning_rate=0.001\n", + "Epoch 304/304 - loss=rnn_1step_loss=0.29953969, rnn_1step_R2_maskV_-1.0=0.69520438, rnn_1step_CC_maskV_-1.0=0.836748, rnn_1step_MSE_maskV_-1.0=0.29953972, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46180239, val_rnn_1step_R2_maskV_-1.0=0.45888799, val_rnn_1step_CC_maskV_-1.0=0.72631139, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:19:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 30.53s\n", + "\u001b[32m2025-05-30 11:19:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:19:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 55 (stopped at 70 epochs).\n", + "\u001b[32m2025-05-30 11:19:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/71 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0008144, rnn_1_1step_R2_maskV_-1.0=-0.013442289, rnn_1_1step_CC_maskV_-1.0=0.11192037, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92085475, val_rnn_1_1step_R2_maskV_-1.0=-0.061996341, val_rnn_1_1step_CC_maskV_-1.0=0.28351876, learning_rate=0.001\n", + "Epoch 9/71 - loss=rnn_1_1step_loss=0.90126342, rnn_1_1step_R2_maskV_-1.0=0.088794887, rnn_1_1step_CC_maskV_-1.0=0.39212301, rnn_1_1step_MSE_maskV_-1.0=0.90126336, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.81273896, val_rnn_1_1step_R2_maskV_-1.0=0.056499764, val_rnn_1_1step_CC_maskV_-1.0=0.3898803, learning_rate=0.001\n", + "Epoch 17/71 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.70814425, rnn_1_1step_R2_maskV_-1.0=0.28236505, rnn_1_1step_CC_maskV_-1.0=0.54319406, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.68296832, val_rnn_1_1step_R2_maskV_-1.0=0.20407628, val_rnn_1_1step_CC_maskV_-1.0=0.50987107, learning_rate=0.001\n", + "Epoch 25/71 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.573533, rnn_1_1step_R2_maskV_-1.0=0.41755962, rnn_1_1step_CC_maskV_-1.0=0.65215015, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61941004, val_rnn_1_1step_R2_maskV_-1.0=0.27871215, val_rnn_1_1step_CC_maskV_-1.0=0.59096384, learning_rate=0.001\n", + "Epoch 33/71 - loss=rnn_1_1step_loss=0.49219069, rnn_1_1step_R2_maskV_-1.0=0.49983263, rnn_1_1step_CC_maskV_-1.0=0.71214861, rnn_1_1step_MSE_maskV_-1.0=0.49219063, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56987661, val_rnn_1_1step_R2_maskV_-1.0=0.33450812, val_rnn_1_1step_CC_maskV_-1.0=0.63828379, learning_rate=0.001\n", + "Epoch 41/71 - loss=rnn_1_1step_loss=0.44274816, rnn_1_1step_R2_maskV_-1.0=0.54975021, rnn_1_1step_CC_maskV_-1.0=0.74629235, rnn_1_1step_MSE_maskV_-1.0=0.44274813, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53496283, val_rnn_1_1step_R2_maskV_-1.0=0.37237406, val_rnn_1_1step_CC_maskV_-1.0=0.66725969, learning_rate=0.001\n", + "Epoch 49/71 - loss=rnn_1_1step_loss=0.41819051, rnn_1_1step_R2_maskV_-1.0=0.57452846, rnn_1_1step_CC_maskV_-1.0=0.76277202, rnn_1_1step_MSE_maskV_-1.0=0.41819054, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52286369, val_rnn_1_1step_R2_maskV_-1.0=0.38603169, val_rnn_1_1step_CC_maskV_-1.0=0.67543626, learning_rate=0.001\n", + "Epoch 57/71 - loss=rnn_1_1step_loss=0.40615788, rnn_1_1step_R2_maskV_-1.0=0.58659542, rnn_1_1step_CC_maskV_-1.0=0.77075171, rnn_1_1step_MSE_maskV_-1.0=0.40615785, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52242881, val_rnn_1_1step_R2_maskV_-1.0=0.38684517, val_rnn_1_1step_CC_maskV_-1.0=0.67543662, learning_rate=0.001\n", + "Epoch 65/71 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39781585, rnn_1_1step_R2_maskV_-1.0=0.59494328, rnn_1_1step_CC_maskV_-1.0=0.77621096, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52392113, val_rnn_1_1step_R2_maskV_-1.0=0.38548702, val_rnn_1_1step_CC_maskV_-1.0=0.67438906, learning_rate=0.001\n", + "Epoch 71/71 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39257845, rnn_1_1step_R2_maskV_-1.0=0.60021013, rnn_1_1step_CC_maskV_-1.0=0.77961481, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52477497, val_rnn_1_1step_R2_maskV_-1.0=0.38470286, val_rnn_1_1step_CC_maskV_-1.0=0.6738025, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:19:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 8.58s\n", + "\u001b[32m2025-05-30 11:19:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.46097469)\n", + "\u001b[32m2025-05-30 11:19:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.278, R2_maskV_-1.0=0.721, CC_maskV_-1.0=0.85\n", + "\u001b[32m2025-05-30 11:19:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.426, R2_maskV_-1.0=0.511, CC_maskV_-1.0=0.757\n", + "\u001b[32m2025-05-30 11:19:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:19:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:19:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 90 (stopped at 105 epochs).\n", + "\u001b[32m2025-05-30 11:19:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/106 - loss=15.802477, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0072547137, MSE_maskV_-1.0=15.758484, val_loss=2.6558001, val_CC_maskV_-1.0=0.03402032, val_MSE_maskV_-1.0=2.6408195, learning_rate=0.001\n", + "Epoch 12/106 - loss=0.9057011, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.32968527, MSE_maskV_-1.0=0.90610665, val_loss=0.93847227, val_CC_maskV_-1.0=0.33179492, val_MSE_maskV_-1.0=0.93442154, learning_rate=0.001\n", + "Epoch 23/106 - loss=0.81880891, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42757213, MSE_maskV_-1.0=0.81862128, val_loss=0.85255551, val_CC_maskV_-1.0=0.42603743, val_MSE_maskV_-1.0=0.84904927, learning_rate=0.001\n", + "Epoch 34/106 - loss=0.78167903, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4672229, MSE_maskV_-1.0=0.78179622, val_loss=0.81861854, val_CC_maskV_-1.0=0.46122506, val_MSE_maskV_-1.0=0.81570512, learning_rate=0.001\n", + "Epoch 45/106 - loss=0.76239157, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48825818, MSE_maskV_-1.0=0.76197153, val_loss=0.79901731, val_CC_maskV_-1.0=0.48027334, val_MSE_maskV_-1.0=0.79667664, learning_rate=0.001\n", + "Epoch 56/106 - loss=0.7497378, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49998155, MSE_maskV_-1.0=0.74996042, val_loss=0.78414464, val_CC_maskV_-1.0=0.49465969, val_MSE_maskV_-1.0=0.78219712, learning_rate=0.001\n", + "Epoch 67/106 - loss=0.73937106, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5104298, MSE_maskV_-1.0=0.73904842, val_loss=0.77870864, val_CC_maskV_-1.0=0.49909258, val_MSE_maskV_-1.0=0.77674818, learning_rate=0.001\n", + "Epoch 78/106 - loss=0.73311007, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51603895, MSE_maskV_-1.0=0.73285222, val_loss=0.77163994, val_CC_maskV_-1.0=0.50656134, val_MSE_maskV_-1.0=0.76995116, learning_rate=0.001\n", + "Epoch 89/106 - loss=0.72847581, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52066797, MSE_maskV_-1.0=0.72873926, val_loss=0.76802838, val_CC_maskV_-1.0=0.5086239, val_MSE_maskV_-1.0=0.76648939, learning_rate=0.001\n", + "Epoch 100/106 - loss=0.72437525, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52402878, MSE_maskV_-1.0=0.72425425, val_loss=0.76093704, val_CC_maskV_-1.0=0.51567447, val_MSE_maskV_-1.0=0.75946867, learning_rate=0.001\n", + "Epoch 106/106 - loss=0.72189134, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52720201, MSE_maskV_-1.0=0.7216925, val_loss=0.759848, val_CC_maskV_-1.0=0.51671034, val_MSE_maskV_-1.0=0.75857013, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:19:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 26.56s\n", + "\u001b[32m2025-05-30 11:19:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:20:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 90 (stopped at 105 epochs).\n", + "\u001b[32m2025-05-30 11:20:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/106 - loss=11.578647, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.026905052, MSE_maskV_-1.0=11.547812, val_loss=2.3630614, val_CC_maskV_-1.0=0.048268724, val_MSE_maskV_-1.0=2.349942, learning_rate=0.001\n", + "Epoch 12/106 - loss=0.8919577, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34906903, MSE_maskV_-1.0=0.89252657, val_loss=0.92190212, val_CC_maskV_-1.0=0.35138774, val_MSE_maskV_-1.0=0.92008072, learning_rate=0.001\n", + "Epoch 23/106 - loss=0.80879277, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43833855, MSE_maskV_-1.0=0.80862129, val_loss=0.84458566, val_CC_maskV_-1.0=0.43221778, val_MSE_maskV_-1.0=0.84264284, learning_rate=0.001\n", + "Epoch 34/106 - loss=0.77483076, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47433919, MSE_maskV_-1.0=0.77492321, val_loss=0.81260347, val_CC_maskV_-1.0=0.46597931, val_MSE_maskV_-1.0=0.81049436, learning_rate=0.001\n", + "Epoch 45/106 - loss=0.75689441, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49388894, MSE_maskV_-1.0=0.75646341, val_loss=0.7942636, val_CC_maskV_-1.0=0.48417926, val_MSE_maskV_-1.0=0.79237545, learning_rate=0.001\n", + "Epoch 56/106 - loss=0.74520302, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50453246, MSE_maskV_-1.0=0.74542481, val_loss=0.78057957, val_CC_maskV_-1.0=0.49765047, val_MSE_maskV_-1.0=0.77891946, learning_rate=0.001\n", + "Epoch 67/106 - loss=0.73523337, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51458913, MSE_maskV_-1.0=0.7348544, val_loss=0.77560371, val_CC_maskV_-1.0=0.50183934, val_MSE_maskV_-1.0=0.77382123, learning_rate=0.001\n", + "Epoch 78/106 - loss=0.72956705, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51950842, MSE_maskV_-1.0=0.72931623, val_loss=0.76935339, val_CC_maskV_-1.0=0.50847155, val_MSE_maskV_-1.0=0.76777768, learning_rate=0.001\n", + "Epoch 89/106 - loss=0.72536767, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52365857, MSE_maskV_-1.0=0.7256031, val_loss=0.7660557, val_CC_maskV_-1.0=0.51030821, val_MSE_maskV_-1.0=0.76459801, learning_rate=0.001\n", + "Epoch 100/106 - loss=0.72176903, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52657729, MSE_maskV_-1.0=0.72166133, val_loss=0.75951976, val_CC_maskV_-1.0=0.51685238, val_MSE_maskV_-1.0=0.75810927, learning_rate=0.001\n", + "Epoch 106/106 - loss=0.71927673, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52977282, MSE_maskV_-1.0=0.71909481, val_loss=0.75855094, val_CC_maskV_-1.0=0.51789421, val_MSE_maskV_-1.0=0.75731796, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:20:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 25.96s\n", + "\u001b[32m2025-05-30 11:20:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.75564522)\n", + "\u001b[32m2025-05-30 11:20:15\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 739us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:20:16\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.722, R2_maskV_-1.0=0.278, CC_maskV_-1.0=0.528\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 719us/step\n", + "51/51 [==============================] - 0s 775us/step\n", + "84/84 [==============================] - 0s 705us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:20:16\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_Cz1HL64U_ErSV16\" (4/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_Cz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:20:16\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_Cy1HL64U_ErSV16\" (5/16)\n", + "\u001b[32m2025-05-30 11:20:16\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_Cy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:20:16\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:20:16\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:20:17\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:20:17\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:20:17\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:20:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:20:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 41 (stopped at 56 epochs).\n", + "\u001b[32m2025-05-30 11:20:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/57 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.001367, rnn_1step_R2_maskV_-1.0=-0.013879158, rnn_1step_CC_maskV_-1.0=0.01396896, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91923064, val_rnn_1step_R2_maskV_-1.0=-0.060198784, val_rnn_1step_CC_maskV_-1.0=0.13037446, learning_rate=0.001\n", + "Epoch 7/57 - loss=rnn_1step_loss=0.93727332, rnn_1step_R2_maskV_-1.0=0.05153463, rnn_1step_CC_maskV_-1.0=0.41341537, rnn_1step_MSE_maskV_-1.0=0.93727338, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.8642714, val_rnn_1step_R2_maskV_-1.0=0.0014747828, val_rnn_1step_CC_maskV_-1.0=0.3623904, learning_rate=0.001\n", + "Epoch 13/57 - loss=rnn_1step_loss=0.79557639, rnn_1step_R2_maskV_-1.0=0.19584404, rnn_1step_CC_maskV_-1.0=0.47322154, rnn_1step_MSE_maskV_-1.0=0.79557645, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.75097632, val_rnn_1step_R2_maskV_-1.0=0.1256357, val_rnn_1step_CC_maskV_-1.0=0.44028974, learning_rate=0.001\n", + "Epoch 19/57 - loss=rnn_1step_loss=0.66549999, rnn_1step_R2_maskV_-1.0=0.32697845, rnn_1step_CC_maskV_-1.0=0.57809544, rnn_1step_MSE_maskV_-1.0=0.66550004, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.66438204, val_rnn_1step_R2_maskV_-1.0=0.22299372, val_rnn_1step_CC_maskV_-1.0=0.54269618, learning_rate=0.001\n", + "Epoch 25/57 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.57543063, rnn_1step_R2_maskV_-1.0=0.41735941, rnn_1step_CC_maskV_-1.0=0.65118885, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60479456, val_rnn_1step_R2_maskV_-1.0=0.29039031, val_rnn_1step_CC_maskV_-1.0=0.6027351, learning_rate=0.001\n", + "Epoch 31/57 - loss=rnn_1step_loss=0.5252319, rnn_1step_R2_maskV_-1.0=0.46831709, rnn_1step_CC_maskV_-1.0=0.68825459, rnn_1step_MSE_maskV_-1.0=0.52523196, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56611228, val_rnn_1step_R2_maskV_-1.0=0.33440849, val_rnn_1step_CC_maskV_-1.0=0.63733542, learning_rate=0.001\n", + "Epoch 37/57 - loss=rnn_1step_loss=0.50052136, rnn_1step_R2_maskV_-1.0=0.49313265, rnn_1step_CC_maskV_-1.0=0.70603538, rnn_1step_MSE_maskV_-1.0=0.5005213, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55904013, val_rnn_1step_R2_maskV_-1.0=0.34295925, val_rnn_1step_CC_maskV_-1.0=0.64480352, learning_rate=0.001\n", + "Epoch 43/57 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.48748493, rnn_1step_R2_maskV_-1.0=0.50601751, rnn_1step_CC_maskV_-1.0=0.71547729, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55833942, val_rnn_1step_R2_maskV_-1.0=0.34403795, val_rnn_1step_CC_maskV_-1.0=0.64512283, learning_rate=0.001\n", + "Epoch 49/57 - loss=rnn_1step_loss=0.47991273, rnn_1step_R2_maskV_-1.0=0.51347655, rnn_1step_CC_maskV_-1.0=0.72096789, rnn_1step_MSE_maskV_-1.0=0.4799127, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56048852, val_rnn_1step_R2_maskV_-1.0=0.34170574, val_rnn_1step_CC_maskV_-1.0=0.64313996, learning_rate=0.001\n", + "Epoch 55/57 - loss=rnn_1step_loss=0.47455907, rnn_1step_R2_maskV_-1.0=0.51876664, rnn_1step_CC_maskV_-1.0=0.72480452, rnn_1step_MSE_maskV_-1.0=0.47455913, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.562563, val_rnn_1step_R2_maskV_-1.0=0.3394255, val_rnn_1step_CC_maskV_-1.0=0.64136583, learning_rate=0.001\n", + "Epoch 57/57 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.47299671, rnn_1step_R2_maskV_-1.0=0.52031326, rnn_1step_CC_maskV_-1.0=0.72591174, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56300884, val_rnn_1step_R2_maskV_-1.0=0.33895564, val_rnn_1step_CC_maskV_-1.0=0.64099282, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:20:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 6.97s\n", + "\u001b[32m2025-05-30 11:20:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:20:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 125 (stopped at 140 epochs).\n", + "\u001b[32m2025-05-30 11:20:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/141 - loss=rnn_1_1step_loss=0.99950618, rnn_1_1step_R2_maskV_-1.0=-0.012062702, rnn_1_1step_CC_maskV_-1.0=0.048678473, rnn_1_1step_MSE_maskV_-1.0=0.99950606, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91861039, val_rnn_1_1step_R2_maskV_-1.0=-0.059418976, val_rnn_1_1step_CC_maskV_-1.0=0.13310967, learning_rate=0.001\n", + "Epoch 16/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.6944809, rnn_1_1step_R2_maskV_-1.0=0.29659778, rnn_1_1step_CC_maskV_-1.0=0.55413347, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.71805435, val_rnn_1_1step_R2_maskV_-1.0=0.16369115, val_rnn_1_1step_CC_maskV_-1.0=0.49326748, learning_rate=0.001\n", + "Epoch 31/141 - loss=rnn_1_1step_loss=0.51692158, rnn_1_1step_R2_maskV_-1.0=0.47485709, rnn_1_1step_CC_maskV_-1.0=0.69464755, rnn_1_1step_MSE_maskV_-1.0=0.51692164, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60543901, val_rnn_1_1step_R2_maskV_-1.0=0.29638574, val_rnn_1_1step_CC_maskV_-1.0=0.60584301, learning_rate=0.001\n", + "Epoch 46/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.46517006, rnn_1_1step_R2_maskV_-1.0=0.52816564, rnn_1_1step_CC_maskV_-1.0=0.73151481, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56311268, val_rnn_1_1step_R2_maskV_-1.0=0.34044409, val_rnn_1_1step_CC_maskV_-1.0=0.63983423, learning_rate=0.001\n", + "Epoch 61/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44313189, rnn_1_1step_R2_maskV_-1.0=0.55078733, rnn_1_1step_CC_maskV_-1.0=0.74600291, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54103088, val_rnn_1_1step_R2_maskV_-1.0=0.3653537, val_rnn_1_1step_CC_maskV_-1.0=0.65851712, learning_rate=0.001\n", + "Epoch 76/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42557895, rnn_1_1step_R2_maskV_-1.0=0.56860298, rnn_1_1step_CC_maskV_-1.0=0.75733668, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52109367, val_rnn_1_1step_R2_maskV_-1.0=0.38818276, val_rnn_1_1step_CC_maskV_-1.0=0.67618883, learning_rate=0.001\n", + "Epoch 91/141 - loss=rnn_1_1step_loss=0.41503525, rnn_1_1step_R2_maskV_-1.0=0.57917988, rnn_1_1step_CC_maskV_-1.0=0.76422924, rnn_1_1step_MSE_maskV_-1.0=0.41503528, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51171559, val_rnn_1_1step_R2_maskV_-1.0=0.39906013, val_rnn_1_1step_CC_maskV_-1.0=0.6842953, learning_rate=0.001\n", + "Epoch 106/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40844607, rnn_1_1step_R2_maskV_-1.0=0.58577347, rnn_1_1step_CC_maskV_-1.0=0.76850206, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50812125, val_rnn_1_1step_R2_maskV_-1.0=0.40314218, val_rnn_1_1step_CC_maskV_-1.0=0.68775612, learning_rate=0.001\n", + "Epoch 121/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40415633, rnn_1_1step_R2_maskV_-1.0=0.59006274, rnn_1_1step_CC_maskV_-1.0=0.77126521, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50721419, val_rnn_1_1step_R2_maskV_-1.0=0.40405986, val_rnn_1_1step_CC_maskV_-1.0=0.689143, learning_rate=0.001\n", + "Epoch 136/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40121159, rnn_1_1step_R2_maskV_-1.0=0.59299648, rnn_1_1step_CC_maskV_-1.0=0.77315891, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50731736, val_rnn_1_1step_R2_maskV_-1.0=0.40385005, val_rnn_1_1step_CC_maskV_-1.0=0.68963385, learning_rate=0.001\n", + "Epoch 141/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40042531, rnn_1_1step_R2_maskV_-1.0=0.5937773, rnn_1_1step_CC_maskV_-1.0=0.77366436, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50739926, val_rnn_1_1step_R2_maskV_-1.0=0.40373752, val_rnn_1_1step_CC_maskV_-1.0=0.68972492, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:20:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 22.04s\n", + "\u001b[32m2025-05-30 11:20:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.5071938)\n", + "\u001b[32m2025-05-30 11:20:47\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.361, R2_maskV_-1.0=0.639, CC_maskV_-1.0=0.8\n", + "\u001b[32m2025-05-30 11:20:47\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.481, R2_maskV_-1.0=0.447, CC_maskV_-1.0=0.715\n", + "\u001b[32m2025-05-30 11:20:47\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:20:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:21:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 121 (stopped at 136 epochs).\n", + "\u001b[32m2025-05-30 11:21:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/137 - loss=1.7217222, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.058090176, MSE_maskV_-1.0=1.719746, val_loss=1.0729501, val_CC_maskV_-1.0=0.12030143, val_MSE_maskV_-1.0=1.0711751, learning_rate=0.001\n", + "Epoch 15/137 - loss=0.77912468, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46900734, MSE_maskV_-1.0=0.77930051, val_loss=0.81180167, val_CC_maskV_-1.0=0.45430753, val_MSE_maskV_-1.0=0.81145394, learning_rate=0.001\n", + "Epoch 29/137 - loss=0.71554911, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53058088, MSE_maskV_-1.0=0.71529543, val_loss=0.74519104, val_CC_maskV_-1.0=0.51920462, val_MSE_maskV_-1.0=0.74460399, learning_rate=0.001\n", + "Epoch 43/137 - loss=0.68720961, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5574311, MSE_maskV_-1.0=0.68699282, val_loss=0.72502548, val_CC_maskV_-1.0=0.53745645, val_MSE_maskV_-1.0=0.72479004, learning_rate=0.001\n", + "Epoch 57/137 - loss=0.67245585, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56971163, MSE_maskV_-1.0=0.67293, val_loss=0.71288246, val_CC_maskV_-1.0=0.54801553, val_MSE_maskV_-1.0=0.71246952, learning_rate=0.001\n", + "Epoch 71/137 - loss=0.66286606, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57805413, MSE_maskV_-1.0=0.66410941, val_loss=0.70428121, val_CC_maskV_-1.0=0.55595541, val_MSE_maskV_-1.0=0.70391721, learning_rate=0.001\n", + "Epoch 85/137 - loss=0.65737545, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58270037, MSE_maskV_-1.0=0.65757811, val_loss=0.69712454, val_CC_maskV_-1.0=0.56086046, val_MSE_maskV_-1.0=0.6968236, learning_rate=0.001\n", + "Epoch 99/137 - loss=0.65141755, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58749044, MSE_maskV_-1.0=0.65122318, val_loss=0.6964789, val_CC_maskV_-1.0=0.56241578, val_MSE_maskV_-1.0=0.69585055, learning_rate=0.001\n", + "Epoch 113/137 - loss=0.64746749, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59138548, MSE_maskV_-1.0=0.65001827, val_loss=0.69698417, val_CC_maskV_-1.0=0.56139702, val_MSE_maskV_-1.0=0.69651443, learning_rate=0.001\n", + "Epoch 127/137 - loss=0.64539462, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59215546, MSE_maskV_-1.0=0.64651847, val_loss=0.68878353, val_CC_maskV_-1.0=0.56641954, val_MSE_maskV_-1.0=0.68835527, learning_rate=0.001\n", + "Epoch 137/137 - loss=0.64185232, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59520411, MSE_maskV_-1.0=0.64164865, val_loss=0.68776894, val_CC_maskV_-1.0=0.56646127, val_MSE_maskV_-1.0=0.6873523, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:21:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 36.27s\n", + "\u001b[32m2025-05-30 11:21:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:22:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 183 (stopped at 198 epochs).\n", + "\u001b[32m2025-05-30 11:22:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/199 - loss=1.9845656, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.077370562, MSE_maskV_-1.0=1.9818332, val_loss=1.091795, val_CC_maskV_-1.0=0.1135402, val_MSE_maskV_-1.0=1.0874971, learning_rate=0.001\n", + "Epoch 21/199 - loss=0.76643455, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4813785, MSE_maskV_-1.0=0.76636082, val_loss=0.80081367, val_CC_maskV_-1.0=0.4670096, val_MSE_maskV_-1.0=0.79945773, learning_rate=0.001\n", + "Epoch 41/199 - loss=0.69713569, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54806632, MSE_maskV_-1.0=0.69750035, val_loss=0.73682386, val_CC_maskV_-1.0=0.52611953, val_MSE_maskV_-1.0=0.73638135, learning_rate=0.001\n", + "Epoch 61/199 - loss=0.67478681, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56836843, MSE_maskV_-1.0=0.67467737, val_loss=0.71494287, val_CC_maskV_-1.0=0.54637039, val_MSE_maskV_-1.0=0.71446061, learning_rate=0.001\n", + "Epoch 81/199 - loss=0.66332042, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57862014, MSE_maskV_-1.0=0.66350216, val_loss=0.70516115, val_CC_maskV_-1.0=0.55335206, val_MSE_maskV_-1.0=0.70550251, learning_rate=0.001\n", + "Epoch 101/199 - loss=0.65583736, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58471644, MSE_maskV_-1.0=0.65530586, val_loss=0.69760799, val_CC_maskV_-1.0=0.56003845, val_MSE_maskV_-1.0=0.6982578, learning_rate=0.001\n", + "Epoch 121/199 - loss=0.6504544, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58831519, MSE_maskV_-1.0=0.6502825, val_loss=0.69219327, val_CC_maskV_-1.0=0.56500781, val_MSE_maskV_-1.0=0.69277042, learning_rate=0.001\n", + "Epoch 141/199 - loss=0.64479858, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59410793, MSE_maskV_-1.0=0.64653099, val_loss=0.69242668, val_CC_maskV_-1.0=0.56332266, val_MSE_maskV_-1.0=0.69321328, learning_rate=0.001\n", + "Epoch 161/199 - loss=0.64164579, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5965187, MSE_maskV_-1.0=0.64219445, val_loss=0.68844354, val_CC_maskV_-1.0=0.56629342, val_MSE_maskV_-1.0=0.68907362, learning_rate=0.001\n", + "Epoch 181/199 - loss=0.63859487, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59830856, MSE_maskV_-1.0=0.63856483, val_loss=0.68316174, val_CC_maskV_-1.0=0.57086176, val_MSE_maskV_-1.0=0.68446547, learning_rate=0.001\n", + "Epoch 199/199 - loss=0.63577765, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60059351, MSE_maskV_-1.0=0.63555574, val_loss=0.69012326, val_CC_maskV_-1.0=0.56562376, val_MSE_maskV_-1.0=0.69089687, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:22:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 54.02s\n", + "\u001b[32m2025-05-30 11:22:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.68089664)\n", + "\u001b[32m2025-05-30 11:22:17\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 753us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:22:18\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.633, R2_maskV_-1.0=0.369, CC_maskV_-1.0=0.607\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 814us/step\n", + "51/51 [==============================] - 0s 881us/step\n", + "84/84 [==============================] - 0s 865us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:22:19\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_Cy1HL64U_ErSV16\" (5/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_Cy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:22:19\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_uAK1HL64U_ErSV16\" (6/16)\n", + "\u001b[32m2025-05-30 11:22:19\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAK1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:22:19\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:22:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:22:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:22:19\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:22:19\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:22:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:22:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 65 (stopped at 80 epochs).\n", + "\u001b[32m2025-05-30 11:22:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/81 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0008491, rnn_1step_R2_maskV_-1.0=-0.013476357, rnn_1step_CC_maskV_-1.0=0.069839001, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92221975, val_rnn_1step_R2_maskV_-1.0=-0.063572198, val_rnn_1step_CC_maskV_-1.0=0.22462098, learning_rate=0.001\n", + "Epoch 10/81 - loss=rnn_1step_loss=0.86422509, rnn_1step_R2_maskV_-1.0=0.1233003, rnn_1step_CC_maskV_-1.0=0.39397371, rnn_1step_MSE_maskV_-1.0=0.86422503, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.81252742, val_rnn_1step_R2_maskV_-1.0=0.057928622, val_rnn_1step_CC_maskV_-1.0=0.38107941, learning_rate=0.001\n", + "Epoch 19/81 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.62154746, rnn_1step_R2_maskV_-1.0=0.36483628, rnn_1step_CC_maskV_-1.0=0.61672068, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6595723, val_rnn_1step_R2_maskV_-1.0=0.23205833, val_rnn_1step_CC_maskV_-1.0=0.55452943, learning_rate=0.001\n", + "Epoch 28/81 - loss=rnn_1step_loss=0.51344866, rnn_1step_R2_maskV_-1.0=0.47515824, rnn_1step_CC_maskV_-1.0=0.69851398, rnn_1step_MSE_maskV_-1.0=0.51344872, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57977623, val_rnn_1step_R2_maskV_-1.0=0.32439664, val_rnn_1step_CC_maskV_-1.0=0.61835974, learning_rate=0.001\n", + "Epoch 37/81 - loss=rnn_1step_loss=0.43013349, rnn_1step_R2_maskV_-1.0=0.56036901, rnn_1step_CC_maskV_-1.0=0.75517929, rnn_1step_MSE_maskV_-1.0=0.43013352, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54877996, val_rnn_1step_R2_maskV_-1.0=0.36106807, val_rnn_1step_CC_maskV_-1.0=0.65111095, learning_rate=0.001\n", + "Epoch 46/81 - loss=rnn_1step_loss=0.36039504, rnn_1step_R2_maskV_-1.0=0.6320014, rnn_1step_CC_maskV_-1.0=0.79959786, rnn_1step_MSE_maskV_-1.0=0.36039501, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50629658, val_rnn_1step_R2_maskV_-1.0=0.41095722, val_rnn_1step_CC_maskV_-1.0=0.68493307, learning_rate=0.001\n", + "Epoch 55/81 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30793318, rnn_1step_R2_maskV_-1.0=0.68611872, rnn_1step_CC_maskV_-1.0=0.83167315, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48647347, val_rnn_1step_R2_maskV_-1.0=0.43492165, val_rnn_1step_CC_maskV_-1.0=0.70213681, learning_rate=0.001\n", + "Epoch 64/81 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.2741904, rnn_1step_R2_maskV_-1.0=0.72126192, rnn_1step_CC_maskV_-1.0=0.85216105, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48270094, val_rnn_1step_R2_maskV_-1.0=0.43968388, val_rnn_1step_CC_maskV_-1.0=0.7086603, learning_rate=0.001\n", + "Epoch 73/81 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.24997978, rnn_1step_R2_maskV_-1.0=0.74619961, rnn_1step_CC_maskV_-1.0=0.8655389, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47975859, val_rnn_1step_R2_maskV_-1.0=0.44263229, val_rnn_1step_CC_maskV_-1.0=0.71155167, learning_rate=0.001\n", + "Epoch 81/81 - loss=rnn_1step_loss=0.23523015, rnn_1step_R2_maskV_-1.0=0.7610724, rnn_1step_CC_maskV_-1.0=0.87437278, rnn_1step_MSE_maskV_-1.0=0.23523016, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47907844, val_rnn_1step_R2_maskV_-1.0=0.44197184, val_rnn_1step_CC_maskV_-1.0=0.71165138, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:22:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.80s\n", + "\u001b[32m2025-05-30 11:22:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:22:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 62 (stopped at 77 epochs).\n", + "\u001b[32m2025-05-30 11:22:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/78 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.000113, rnn_1_1step_R2_maskV_-1.0=-0.012750745, rnn_1_1step_CC_maskV_-1.0=0.17361641, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92025852, val_rnn_1_1step_R2_maskV_-1.0=-0.061246827, val_rnn_1_1step_CC_maskV_-1.0=0.33121827, learning_rate=0.001\n", + "Epoch 9/78 - loss=rnn_1_1step_loss=0.87725669, rnn_1_1step_R2_maskV_-1.0=0.111655, rnn_1_1step_CC_maskV_-1.0=0.40042597, rnn_1_1step_MSE_maskV_-1.0=0.87725663, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.78431243, val_rnn_1_1step_R2_maskV_-1.0=0.091919944, val_rnn_1_1step_CC_maskV_-1.0=0.40086102, learning_rate=0.001\n", + "Epoch 17/78 - loss=rnn_1_1step_loss=0.65844733, rnn_1_1step_R2_maskV_-1.0=0.32990748, rnn_1_1step_CC_maskV_-1.0=0.59028, rnn_1_1step_MSE_maskV_-1.0=0.65844738, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65127283, val_rnn_1_1step_R2_maskV_-1.0=0.24268572, val_rnn_1_1step_CC_maskV_-1.0=0.54213017, learning_rate=0.001\n", + "Epoch 25/78 - loss=rnn_1_1step_loss=0.53080457, rnn_1_1step_R2_maskV_-1.0=0.45828378, rnn_1_1step_CC_maskV_-1.0=0.68517101, rnn_1_1step_MSE_maskV_-1.0=0.53080463, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58343506, val_rnn_1_1step_R2_maskV_-1.0=0.32154781, val_rnn_1_1step_CC_maskV_-1.0=0.6167376, learning_rate=0.001\n", + "Epoch 33/78 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44852543, rnn_1_1step_R2_maskV_-1.0=0.54192472, rnn_1_1step_CC_maskV_-1.0=0.74235886, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54308534, val_rnn_1_1step_R2_maskV_-1.0=0.36809701, val_rnn_1_1step_CC_maskV_-1.0=0.65545952, learning_rate=0.001\n", + "Epoch 41/78 - loss=rnn_1_1step_loss=0.38450244, rnn_1_1step_R2_maskV_-1.0=0.60771608, rnn_1_1step_CC_maskV_-1.0=0.78411728, rnn_1_1step_MSE_maskV_-1.0=0.38450247, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50012809, val_rnn_1_1step_R2_maskV_-1.0=0.41690952, val_rnn_1_1step_CC_maskV_-1.0=0.6928063, learning_rate=0.001\n", + "Epoch 49/78 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.3409265, rnn_1_1step_R2_maskV_-1.0=0.65326536, rnn_1_1step_CC_maskV_-1.0=0.81277013, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48997518, val_rnn_1_1step_R2_maskV_-1.0=0.42722869, val_rnn_1_1step_CC_maskV_-1.0=0.70395005, learning_rate=0.001\n", + "Epoch 57/78 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30878285, rnn_1_1step_R2_maskV_-1.0=0.68665183, rnn_1_1step_CC_maskV_-1.0=0.83201253, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46042714, val_rnn_1_1step_R2_maskV_-1.0=0.46206376, val_rnn_1_1step_CC_maskV_-1.0=0.72039825, learning_rate=0.001\n", + "Epoch 65/78 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.28513774, rnn_1_1step_R2_maskV_-1.0=0.71089232, rnn_1_1step_CC_maskV_-1.0=0.84479022, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49909711, val_rnn_1_1step_R2_maskV_-1.0=0.41894519, val_rnn_1_1step_CC_maskV_-1.0=0.70478272, learning_rate=0.001\n", + "Epoch 73/78 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.27095306, rnn_1_1step_R2_maskV_-1.0=0.72528881, rnn_1_1step_CC_maskV_-1.0=0.85331374, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47230411, val_rnn_1_1step_R2_maskV_-1.0=0.44892398, val_rnn_1_1step_CC_maskV_-1.0=0.71719766, learning_rate=0.001\n", + "Epoch 78/78 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.26295495, rnn_1_1step_R2_maskV_-1.0=0.7333737, rnn_1_1step_CC_maskV_-1.0=0.85818082, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46446514, val_rnn_1_1step_R2_maskV_-1.0=0.45751604, val_rnn_1_1step_CC_maskV_-1.0=0.7186029, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:22:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.48s\n", + "\u001b[32m2025-05-30 11:22:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.4532558)\n", + "\u001b[32m2025-05-30 11:22:42\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.261, R2_maskV_-1.0=0.738, CC_maskV_-1.0=0.859\n", + "\u001b[32m2025-05-30 11:22:42\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.441, R2_maskV_-1.0=0.496, CC_maskV_-1.0=0.738\n", + "\u001b[32m2025-05-30 11:22:42\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:22:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:23:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 298 (stopped at 313 epochs).\n", + "\u001b[32m2025-05-30 11:23:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/314 - loss=1.7893338, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.025723534, MSE_maskV_-1.0=1.7873137, val_loss=1.1250548, val_CC_maskV_-1.0=0.06908825, val_MSE_maskV_-1.0=1.1224288, learning_rate=0.001\n", + "Epoch 33/314 - loss=0.91591179, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.29518306, MSE_maskV_-1.0=0.91531372, val_loss=0.95787102, val_CC_maskV_-1.0=0.27982345, val_MSE_maskV_-1.0=0.95504814, learning_rate=0.001\n", + "Epoch 65/314 - loss=0.89608741, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.32879308, MSE_maskV_-1.0=0.89498478, val_loss=0.93975794, val_CC_maskV_-1.0=0.30995291, val_MSE_maskV_-1.0=0.93756056, learning_rate=0.001\n", + "Epoch 97/314 - loss=0.88360411, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34747812, MSE_maskV_-1.0=0.88308352, val_loss=0.9246816, val_CC_maskV_-1.0=0.33518395, val_MSE_maskV_-1.0=0.92169869, learning_rate=0.001\n", + "Epoch 129/314 - loss=0.87484926, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35942367, MSE_maskV_-1.0=0.87490845, val_loss=0.91813362, val_CC_maskV_-1.0=0.34228697, val_MSE_maskV_-1.0=0.91551125, learning_rate=0.001\n", + "Epoch 161/314 - loss=0.86816335, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36826819, MSE_maskV_-1.0=0.86844033, val_loss=0.91050321, val_CC_maskV_-1.0=0.35319877, val_MSE_maskV_-1.0=0.90706903, learning_rate=0.001\n", + "Epoch 193/314 - loss=0.86284703, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37613225, MSE_maskV_-1.0=0.86273915, val_loss=0.90661502, val_CC_maskV_-1.0=0.35749292, val_MSE_maskV_-1.0=0.90356857, learning_rate=0.001\n", + "Epoch 225/314 - loss=0.85897171, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38023862, MSE_maskV_-1.0=0.85900164, val_loss=0.90181285, val_CC_maskV_-1.0=0.36407349, val_MSE_maskV_-1.0=0.8987416, learning_rate=0.001\n", + "Epoch 257/314 - loss=0.85569668, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38394403, MSE_maskV_-1.0=0.85566878, val_loss=0.90014434, val_CC_maskV_-1.0=0.36462754, val_MSE_maskV_-1.0=0.89733446, learning_rate=0.001\n", + "Epoch 289/314 - loss=0.85287541, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38757783, MSE_maskV_-1.0=0.85246223, val_loss=0.89548498, val_CC_maskV_-1.0=0.37249172, val_MSE_maskV_-1.0=0.89138687, learning_rate=0.001\n", + "Epoch 314/314 - loss=0.85094225, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39013556, MSE_maskV_-1.0=0.85060626, val_loss=0.89316922, val_CC_maskV_-1.0=0.37385511, val_MSE_maskV_-1.0=0.88983124, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:23:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 76.59s\n", + "\u001b[32m2025-05-30 11:23:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:25:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 298 (stopped at 313 epochs).\n", + "\u001b[32m2025-05-30 11:25:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/314 - loss=1.7081656, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.063234851, MSE_maskV_-1.0=1.7064675, val_loss=1.08805, val_CC_maskV_-1.0=0.11774134, val_MSE_maskV_-1.0=1.0873196, learning_rate=0.001\n", + "Epoch 33/314 - loss=0.91398436, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.29877359, MSE_maskV_-1.0=0.91338223, val_loss=0.95571327, val_CC_maskV_-1.0=0.28475022, val_MSE_maskV_-1.0=0.95272911, learning_rate=0.001\n", + "Epoch 65/314 - loss=0.89495587, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.33055401, MSE_maskV_-1.0=0.89385134, val_loss=0.93842638, val_CC_maskV_-1.0=0.31251934, val_MSE_maskV_-1.0=0.93611759, learning_rate=0.001\n", + "Epoch 97/314 - loss=0.88286823, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34848607, MSE_maskV_-1.0=0.88236612, val_loss=0.92398202, val_CC_maskV_-1.0=0.33641508, val_MSE_maskV_-1.0=0.92091626, learning_rate=0.001\n", + "Epoch 129/314 - loss=0.87434113, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36001197, MSE_maskV_-1.0=0.87440914, val_loss=0.91771084, val_CC_maskV_-1.0=0.34304824, val_MSE_maskV_-1.0=0.91498739, learning_rate=0.001\n", + "Epoch 161/314 - loss=0.86778873, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36870185, MSE_maskV_-1.0=0.8680414, val_loss=0.91022134, val_CC_maskV_-1.0=0.35362065, val_MSE_maskV_-1.0=0.90670365, learning_rate=0.001\n", + "Epoch 193/314 - loss=0.86255836, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37643909, MSE_maskV_-1.0=0.86246097, val_loss=0.90639204, val_CC_maskV_-1.0=0.35782555, val_MSE_maskV_-1.0=0.90327859, learning_rate=0.001\n", + "Epoch 225/314 - loss=0.85873872, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38050011, MSE_maskV_-1.0=0.85876322, val_loss=0.90156698, val_CC_maskV_-1.0=0.36440939, val_MSE_maskV_-1.0=0.89845771, learning_rate=0.001\n", + "Epoch 257/314 - loss=0.85550612, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38414052, MSE_maskV_-1.0=0.85547739, val_loss=0.90001035, val_CC_maskV_-1.0=0.36477935, val_MSE_maskV_-1.0=0.8971628, learning_rate=0.001\n", + "Epoch 289/314 - loss=0.85272062, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38775319, MSE_maskV_-1.0=0.85231048, val_loss=0.89535636, val_CC_maskV_-1.0=0.37266073, val_MSE_maskV_-1.0=0.89121687, learning_rate=0.001\n", + "Epoch 314/314 - loss=0.85080737, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3902398, MSE_maskV_-1.0=0.85048079, val_loss=0.89304483, val_CC_maskV_-1.0=0.37398747, val_MSE_maskV_-1.0=0.88966542, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:25:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 75.90s\n", + "\u001b[32m2025-05-30 11:25:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.89195055)\n", + "\u001b[32m2025-05-30 11:25:14\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 750us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:25:15\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.851, R2_maskV_-1.0=0.149, CC_maskV_-1.0=0.389\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 738us/step\n", + "51/51 [==============================] - 0s 742us/step\n", + "84/84 [==============================] - 0s 711us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:25:16\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_uAK1HL64U_ErSV16\" (6/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_uAK1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:25:16\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_ACz1HL64U_ErSV16\" (7/16)\n", + "\u001b[32m2025-05-30 11:25:16\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:25:16\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:25:16\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:25:16\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:25:16\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:25:16\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:25:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:25:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 111 (stopped at 126 epochs).\n", + "\u001b[32m2025-05-30 11:25:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/127 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0003505, rnn_1step_R2_maskV_-1.0=-0.012977447, rnn_1step_CC_maskV_-1.0=0.13575153, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91990775, val_rnn_1step_R2_maskV_-1.0=-0.060848221, val_rnn_1step_CC_maskV_-1.0=0.33797917, learning_rate=0.001\n", + "Epoch 14/127 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.75803965, rnn_1step_R2_maskV_-1.0=0.2311701, rnn_1step_CC_maskV_-1.0=0.49792093, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.72889227, val_rnn_1step_R2_maskV_-1.0=0.15048452, val_rnn_1step_CC_maskV_-1.0=0.47531152, learning_rate=0.001\n", + "Epoch 27/127 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.55267549, rnn_1step_R2_maskV_-1.0=0.43729362, rnn_1step_CC_maskV_-1.0=0.66949284, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60710889, val_rnn_1step_R2_maskV_-1.0=0.29447472, val_rnn_1step_CC_maskV_-1.0=0.59089547, learning_rate=0.001\n", + "Epoch 40/127 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.48359919, rnn_1step_R2_maskV_-1.0=0.50713068, rnn_1step_CC_maskV_-1.0=0.71856624, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57091755, val_rnn_1step_R2_maskV_-1.0=0.33699661, val_rnn_1step_CC_maskV_-1.0=0.62680662, learning_rate=0.001\n", + "Epoch 53/127 - loss=rnn_1step_loss=0.44961929, rnn_1step_R2_maskV_-1.0=0.54170895, rnn_1step_CC_maskV_-1.0=0.74209249, rnn_1step_MSE_maskV_-1.0=0.44961932, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55982012, val_rnn_1step_R2_maskV_-1.0=0.35020956, val_rnn_1step_CC_maskV_-1.0=0.63735801, learning_rate=0.001\n", + "Epoch 66/127 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42042685, rnn_1step_R2_maskV_-1.0=0.57161629, rnn_1step_CC_maskV_-1.0=0.76245666, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53703332, val_rnn_1step_R2_maskV_-1.0=0.37596893, val_rnn_1step_CC_maskV_-1.0=0.65366626, learning_rate=0.001\n", + "Epoch 79/127 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39642683, rnn_1step_R2_maskV_-1.0=0.59628308, rnn_1step_CC_maskV_-1.0=0.77719164, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51348215, val_rnn_1step_R2_maskV_-1.0=0.40224534, val_rnn_1step_CC_maskV_-1.0=0.67417365, learning_rate=0.001\n", + "Epoch 92/127 - loss=rnn_1step_loss=0.38001299, rnn_1step_R2_maskV_-1.0=0.61309814, rnn_1step_CC_maskV_-1.0=0.78848183, rnn_1step_MSE_maskV_-1.0=0.38001296, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49205908, val_rnn_1step_R2_maskV_-1.0=0.42626777, val_rnn_1step_CC_maskV_-1.0=0.68921399, learning_rate=0.001\n", + "Epoch 105/127 - loss=rnn_1step_loss=0.36460891, rnn_1step_R2_maskV_-1.0=0.62907374, rnn_1step_CC_maskV_-1.0=0.79759794, rnn_1step_MSE_maskV_-1.0=0.36460894, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49810696, val_rnn_1step_R2_maskV_-1.0=0.41750413, val_rnn_1step_CC_maskV_-1.0=0.68754232, learning_rate=0.001\n", + "Epoch 118/127 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35406473, rnn_1step_R2_maskV_-1.0=0.64005548, rnn_1step_CC_maskV_-1.0=0.80389494, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49321461, val_rnn_1step_R2_maskV_-1.0=0.42310452, val_rnn_1step_CC_maskV_-1.0=0.69422174, learning_rate=0.001\n", + "Epoch 127/127 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35581219, rnn_1step_R2_maskV_-1.0=0.63834, rnn_1step_CC_maskV_-1.0=0.80296004, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52084816, val_rnn_1step_R2_maskV_-1.0=0.38876668, val_rnn_1step_CC_maskV_-1.0=0.68152124, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:25:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.81s\n", + "\u001b[32m2025-05-30 11:25:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:25:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 129 (stopped at 144 epochs).\n", + "\u001b[32m2025-05-30 11:25:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/145 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0011529, rnn_1_1step_R2_maskV_-1.0=-0.013802826, rnn_1_1step_CC_maskV_-1.0=0.060428299, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.9217971, val_rnn_1_1step_R2_maskV_-1.0=-0.063040867, val_rnn_1_1step_CC_maskV_-1.0=0.24878301, learning_rate=0.001\n", + "Epoch 16/145 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.71022654, rnn_1_1step_R2_maskV_-1.0=0.27959064, rnn_1_1step_CC_maskV_-1.0=0.54509139, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.69215441, val_rnn_1_1step_R2_maskV_-1.0=0.19466086, val_rnn_1_1step_CC_maskV_-1.0=0.49444467, learning_rate=0.001\n", + "Epoch 31/145 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.5429402, rnn_1_1step_R2_maskV_-1.0=0.44730636, rnn_1_1step_CC_maskV_-1.0=0.67633224, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61085892, val_rnn_1_1step_R2_maskV_-1.0=0.29282641, val_rnn_1_1step_CC_maskV_-1.0=0.59399956, learning_rate=0.001\n", + "Epoch 46/145 - loss=rnn_1_1step_loss=0.47937036, rnn_1_1step_R2_maskV_-1.0=0.51214069, rnn_1_1step_CC_maskV_-1.0=0.72166717, rnn_1_1step_MSE_maskV_-1.0=0.47937039, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57537305, val_rnn_1_1step_R2_maskV_-1.0=0.3325361, val_rnn_1_1step_CC_maskV_-1.0=0.63134807, learning_rate=0.001\n", + "Epoch 61/145 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42984474, rnn_1_1step_R2_maskV_-1.0=0.56252021, rnn_1_1step_CC_maskV_-1.0=0.75466096, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5533914, val_rnn_1_1step_R2_maskV_-1.0=0.3536132, val_rnn_1_1step_CC_maskV_-1.0=0.65865403, learning_rate=0.001\n", + "Epoch 76/145 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.4045352, rnn_1_1step_R2_maskV_-1.0=0.5883311, rnn_1_1step_CC_maskV_-1.0=0.77163833, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.524966, val_rnn_1_1step_R2_maskV_-1.0=0.38483328, val_rnn_1_1step_CC_maskV_-1.0=0.67439073, learning_rate=0.001\n", + "Epoch 91/145 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38195351, rnn_1_1step_R2_maskV_-1.0=0.61150628, rnn_1_1step_CC_maskV_-1.0=0.78687561, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49272361, val_rnn_1_1step_R2_maskV_-1.0=0.42219916, val_rnn_1_1step_CC_maskV_-1.0=0.69783437, learning_rate=0.001\n", + "Epoch 106/145 - loss=rnn_1_1step_loss=0.37524509, rnn_1_1step_R2_maskV_-1.0=0.61858302, rnn_1_1step_CC_maskV_-1.0=0.79065812, rnn_1_1step_MSE_maskV_-1.0=0.37524506, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51020139, val_rnn_1_1step_R2_maskV_-1.0=0.39876777, val_rnn_1_1step_CC_maskV_-1.0=0.69136739, learning_rate=0.001\n", + "Epoch 121/145 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.35628593, rnn_1_1step_R2_maskV_-1.0=0.63796133, rnn_1_1step_CC_maskV_-1.0=0.80280054, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50383109, val_rnn_1_1step_R2_maskV_-1.0=0.4064517, val_rnn_1_1step_CC_maskV_-1.0=0.69755256, learning_rate=0.001\n", + "Epoch 136/145 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.35329938, rnn_1_1step_R2_maskV_-1.0=0.64108491, rnn_1_1step_CC_maskV_-1.0=0.80442947, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46464214, val_rnn_1_1step_R2_maskV_-1.0=0.45382449, val_rnn_1_1step_CC_maskV_-1.0=0.71760577, learning_rate=0.001\n", + "Epoch 145/145 - loss=rnn_1_1step_loss=0.3385478, rnn_1_1step_R2_maskV_-1.0=0.65608472, rnn_1_1step_CC_maskV_-1.0=0.8146739, rnn_1_1step_MSE_maskV_-1.0=0.33854777, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47206783, val_rnn_1_1step_R2_maskV_-1.0=0.4465223, val_rnn_1_1step_CC_maskV_-1.0=0.71320653, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:25:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 17.39s\n", + "\u001b[32m2025-05-30 11:25:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.45702124)\n", + "\u001b[32m2025-05-30 11:25:51\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.327, R2_maskV_-1.0=0.673, CC_maskV_-1.0=0.821\n", + "\u001b[32m2025-05-30 11:25:51\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.434, R2_maskV_-1.0=0.502, CC_maskV_-1.0=0.741\n", + "\u001b[32m2025-05-30 11:25:51\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:25:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:26:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 90 (stopped at 105 epochs).\n", + "\u001b[32m2025-05-30 11:26:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/106 - loss=2.22962, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.037693486, MSE_maskV_-1.0=2.2266648, val_loss=1.2332723, val_CC_maskV_-1.0=0.11544205, val_MSE_maskV_-1.0=1.22763, learning_rate=0.001\n", + "Epoch 12/106 - loss=0.79186231, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45524499, MSE_maskV_-1.0=0.79232615, val_loss=0.82194525, val_CC_maskV_-1.0=0.45016307, val_MSE_maskV_-1.0=0.81997794, learning_rate=0.001\n", + "Epoch 23/106 - loss=0.75222272, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49693108, MSE_maskV_-1.0=0.7521373, val_loss=0.78258258, val_CC_maskV_-1.0=0.48858756, val_MSE_maskV_-1.0=0.78098887, learning_rate=0.001\n", + "Epoch 34/106 - loss=0.7340548, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51463336, MSE_maskV_-1.0=0.7342031, val_loss=0.76845384, val_CC_maskV_-1.0=0.50283194, val_MSE_maskV_-1.0=0.76617432, learning_rate=0.001\n", + "Epoch 45/106 - loss=0.72503906, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52360725, MSE_maskV_-1.0=0.72466648, val_loss=0.7578432, val_CC_maskV_-1.0=0.51208204, val_MSE_maskV_-1.0=0.75602567, learning_rate=0.001\n", + "Epoch 56/106 - loss=0.71900898, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52851599, MSE_maskV_-1.0=0.71908623, val_loss=0.7520358, val_CC_maskV_-1.0=0.51808125, val_MSE_maskV_-1.0=0.75013685, learning_rate=0.001\n", + "Epoch 67/106 - loss=0.7151897, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53267735, MSE_maskV_-1.0=0.71481842, val_loss=0.7494964, val_CC_maskV_-1.0=0.52006799, val_MSE_maskV_-1.0=0.74809009, learning_rate=0.001\n", + "Epoch 78/106 - loss=0.71296674, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53368789, MSE_maskV_-1.0=0.71268511, val_loss=0.74732798, val_CC_maskV_-1.0=0.52268797, val_MSE_maskV_-1.0=0.74535125, learning_rate=0.001\n", + "Epoch 89/106 - loss=0.71136475, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53581762, MSE_maskV_-1.0=0.71164685, val_loss=0.74305809, val_CC_maskV_-1.0=0.52647388, val_MSE_maskV_-1.0=0.74119294, learning_rate=0.001\n", + "Epoch 100/106 - loss=0.70977914, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53650707, MSE_maskV_-1.0=0.70977598, val_loss=0.74206781, val_CC_maskV_-1.0=0.52690816, val_MSE_maskV_-1.0=0.74038261, learning_rate=0.001\n", + "Epoch 106/106 - loss=0.70927078, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53777695, MSE_maskV_-1.0=0.7091226, val_loss=0.74293381, val_CC_maskV_-1.0=0.52599579, val_MSE_maskV_-1.0=0.74147004, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:26:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 26.65s\n", + "\u001b[32m2025-05-30 11:26:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:26:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 90 (stopped at 105 epochs).\n", + "\u001b[32m2025-05-30 11:26:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/106 - loss=2.3235111, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.04634887, MSE_maskV_-1.0=2.3203559, val_loss=1.2569366, val_CC_maskV_-1.0=0.10018728, val_MSE_maskV_-1.0=1.2600317, learning_rate=0.001\n", + "Epoch 12/106 - loss=0.79516369, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45217061, MSE_maskV_-1.0=0.79561847, val_loss=0.82299614, val_CC_maskV_-1.0=0.45213622, val_MSE_maskV_-1.0=0.82094949, learning_rate=0.001\n", + "Epoch 23/106 - loss=0.75166088, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49799657, MSE_maskV_-1.0=0.75158495, val_loss=0.78060567, val_CC_maskV_-1.0=0.49200952, val_MSE_maskV_-1.0=0.7792601, learning_rate=0.001\n", + "Epoch 34/106 - loss=0.7333858, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51547277, MSE_maskV_-1.0=0.73350406, val_loss=0.76684457, val_CC_maskV_-1.0=0.50496501, val_MSE_maskV_-1.0=0.76484936, learning_rate=0.001\n", + "Epoch 45/106 - loss=0.72461283, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52408969, MSE_maskV_-1.0=0.72423708, val_loss=0.7569567, val_CC_maskV_-1.0=0.51320648, val_MSE_maskV_-1.0=0.75538838, learning_rate=0.001\n", + "Epoch 56/106 - loss=0.71880811, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52870327, MSE_maskV_-1.0=0.71889251, val_loss=0.75147027, val_CC_maskV_-1.0=0.51865697, val_MSE_maskV_-1.0=0.7498129, learning_rate=0.001\n", + "Epoch 67/106 - loss=0.71517009, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53266931, MSE_maskV_-1.0=0.71480155, val_loss=0.74895728, val_CC_maskV_-1.0=0.52058429, val_MSE_maskV_-1.0=0.74772739, learning_rate=0.001\n", + "Epoch 78/106 - loss=0.71303672, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53363514, MSE_maskV_-1.0=0.7127589, val_loss=0.7468487, val_CC_maskV_-1.0=0.52310497, val_MSE_maskV_-1.0=0.74500513, learning_rate=0.001\n", + "Epoch 89/106 - loss=0.71148276, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53567749, MSE_maskV_-1.0=0.71176815, val_loss=0.74270266, val_CC_maskV_-1.0=0.52671468, val_MSE_maskV_-1.0=0.74099058, learning_rate=0.001\n", + "Epoch 100/106 - loss=0.7099058, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53634232, MSE_maskV_-1.0=0.70990044, val_loss=0.74184138, val_CC_maskV_-1.0=0.5270471, val_MSE_maskV_-1.0=0.74027681, learning_rate=0.001\n", + "Epoch 106/106 - loss=0.70939654, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53763455, MSE_maskV_-1.0=0.70925415, val_loss=0.74272609, val_CC_maskV_-1.0=0.52613455, val_MSE_maskV_-1.0=0.7413612, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:26:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 26.29s\n", + "\u001b[32m2025-05-30 11:26:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.73951375)\n", + "\u001b[32m2025-05-30 11:26:44\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 741us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:26:44\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.71, R2_maskV_-1.0=0.291, CC_maskV_-1.0=0.539\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 777us/step\n", + "51/51 [==============================] - 0s 728us/step\n", + "84/84 [==============================] - 0s 733us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:26:45\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_ACz1HL64U_ErSV16\" (7/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_ACz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:26:45\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_ACy1HL64U_ErSV16\" (8/16)\n", + "\u001b[32m2025-05-30 11:26:45\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:26:45\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:26:45\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:26:45\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:26:45\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:26:45\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:26:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:26:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 68 (stopped at 83 epochs).\n", + "\u001b[32m2025-05-30 11:26:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/84 - loss=rnn_1step_loss=1.000625, rnn_1step_R2_maskV_-1.0=-0.012994308, rnn_1step_CC_maskV_-1.0=0.02869707, rnn_1step_MSE_maskV_-1.0=1.0006251, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91641647, val_rnn_1step_R2_maskV_-1.0=-0.05748418, val_rnn_1step_CC_maskV_-1.0=0.18311042, learning_rate=0.001\n", + "Epoch 10/84 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.85968381, rnn_1step_R2_maskV_-1.0=0.1304566, rnn_1step_CC_maskV_-1.0=0.41362363, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.79131907, val_rnn_1step_R2_maskV_-1.0=0.078314528, val_rnn_1step_CC_maskV_-1.0=0.3804855, learning_rate=0.001\n", + "Epoch 19/84 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.7062068, rnn_1step_R2_maskV_-1.0=0.28505462, rnn_1step_CC_maskV_-1.0=0.54481918, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.68943554, val_rnn_1step_R2_maskV_-1.0=0.19306098, val_rnn_1step_CC_maskV_-1.0=0.50474894, learning_rate=0.001\n", + "Epoch 28/84 - loss=rnn_1step_loss=0.58783168, rnn_1step_R2_maskV_-1.0=0.40324467, rnn_1step_CC_maskV_-1.0=0.64036036, rnn_1step_MSE_maskV_-1.0=0.58783174, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63411438, val_rnn_1step_R2_maskV_-1.0=0.25854701, val_rnn_1step_CC_maskV_-1.0=0.57707703, learning_rate=0.001\n", + "Epoch 37/84 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.48782539, rnn_1step_R2_maskV_-1.0=0.5044542, rnn_1step_CC_maskV_-1.0=0.71468914, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57277536, val_rnn_1step_R2_maskV_-1.0=0.32931089, val_rnn_1step_CC_maskV_-1.0=0.63367194, learning_rate=0.001\n", + "Epoch 46/84 - loss=rnn_1step_loss=0.4484024, rnn_1step_R2_maskV_-1.0=0.54485554, rnn_1step_CC_maskV_-1.0=0.74305177, rnn_1step_MSE_maskV_-1.0=0.44840243, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53422844, val_rnn_1step_R2_maskV_-1.0=0.37247205, val_rnn_1step_CC_maskV_-1.0=0.66013986, learning_rate=0.001\n", + "Epoch 55/84 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42784929, rnn_1step_R2_maskV_-1.0=0.56601447, rnn_1step_CC_maskV_-1.0=0.75608605, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51475906, val_rnn_1step_R2_maskV_-1.0=0.39540389, val_rnn_1step_CC_maskV_-1.0=0.67277104, learning_rate=0.001\n", + "Epoch 64/84 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41335657, rnn_1step_R2_maskV_-1.0=0.58030045, rnn_1step_CC_maskV_-1.0=0.76609677, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51941991, val_rnn_1step_R2_maskV_-1.0=0.3918204, val_rnn_1step_CC_maskV_-1.0=0.67282432, learning_rate=0.001\n", + "Epoch 73/84 - loss=rnn_1step_loss=0.40978992, rnn_1step_R2_maskV_-1.0=0.58399481, rnn_1step_CC_maskV_-1.0=0.76751435, rnn_1step_MSE_maskV_-1.0=0.40978989, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5353747, val_rnn_1step_R2_maskV_-1.0=0.36956808, val_rnn_1step_CC_maskV_-1.0=0.67217654, learning_rate=0.001\n", + "Epoch 82/84 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4015089, rnn_1step_R2_maskV_-1.0=0.59239697, rnn_1step_CC_maskV_-1.0=0.77311295, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50042224, val_rnn_1step_R2_maskV_-1.0=0.41262498, val_rnn_1step_CC_maskV_-1.0=0.68823212, learning_rate=0.001\n", + "Epoch 84/84 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40070125, rnn_1step_R2_maskV_-1.0=0.59331959, rnn_1step_CC_maskV_-1.0=0.77408624, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50957799, val_rnn_1step_R2_maskV_-1.0=0.40119785, val_rnn_1step_CC_maskV_-1.0=0.68422508, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:26:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.26s\n", + "\u001b[32m2025-05-30 11:26:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:27:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 125 (stopped at 140 epochs).\n", + "\u001b[32m2025-05-30 11:27:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.99979496, rnn_1_1step_R2_maskV_-1.0=-0.012228604, rnn_1_1step_CC_maskV_-1.0=0.048196591, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91654223, val_rnn_1_1step_R2_maskV_-1.0=-0.057550028, val_rnn_1_1step_CC_maskV_-1.0=0.18532029, learning_rate=0.001\n", + "Epoch 16/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.72966021, rnn_1_1step_R2_maskV_-1.0=0.26020464, rnn_1_1step_CC_maskV_-1.0=0.52205557, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.70357585, val_rnn_1_1step_R2_maskV_-1.0=0.17620349, val_rnn_1_1step_CC_maskV_-1.0=0.49321008, learning_rate=0.001\n", + "Epoch 31/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.56371933, rnn_1_1step_R2_maskV_-1.0=0.42698964, rnn_1_1step_CC_maskV_-1.0=0.66042757, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62840515, val_rnn_1_1step_R2_maskV_-1.0=0.26734045, val_rnn_1_1step_CC_maskV_-1.0=0.57872975, learning_rate=0.001\n", + "Epoch 46/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.51070964, rnn_1_1step_R2_maskV_-1.0=0.48048985, rnn_1_1step_CC_maskV_-1.0=0.69909036, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60386086, val_rnn_1_1step_R2_maskV_-1.0=0.29669172, val_rnn_1_1step_CC_maskV_-1.0=0.60509837, learning_rate=0.001\n", + "Epoch 61/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.46321249, rnn_1_1step_R2_maskV_-1.0=0.5289073, rnn_1_1step_CC_maskV_-1.0=0.73262721, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58393401, val_rnn_1_1step_R2_maskV_-1.0=0.31801867, val_rnn_1_1step_CC_maskV_-1.0=0.62246621, learning_rate=0.001\n", + "Epoch 76/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42994413, rnn_1_1step_R2_maskV_-1.0=0.56291056, rnn_1_1step_CC_maskV_-1.0=0.75558496, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5772925, val_rnn_1_1step_R2_maskV_-1.0=0.32168251, val_rnn_1_1step_CC_maskV_-1.0=0.64214784, learning_rate=0.001\n", + "Epoch 91/141 - loss=rnn_1_1step_loss=0.41340557, rnn_1_1step_R2_maskV_-1.0=0.57987314, rnn_1_1step_CC_maskV_-1.0=0.76569331, rnn_1_1step_MSE_maskV_-1.0=0.4134056, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55808884, val_rnn_1_1step_R2_maskV_-1.0=0.34533575, val_rnn_1_1step_CC_maskV_-1.0=0.6505813, learning_rate=0.001\n", + "Epoch 106/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39674649, rnn_1_1step_R2_maskV_-1.0=0.59675103, rnn_1_1step_CC_maskV_-1.0=0.7771672, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52124673, val_rnn_1_1step_R2_maskV_-1.0=0.39064494, val_rnn_1_1step_CC_maskV_-1.0=0.66790843, learning_rate=0.001\n", + "Epoch 121/141 - loss=rnn_1_1step_loss=0.39521936, rnn_1_1step_R2_maskV_-1.0=0.59778357, rnn_1_1step_CC_maskV_-1.0=0.77893275, rnn_1_1step_MSE_maskV_-1.0=0.39521939, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51110834, val_rnn_1_1step_R2_maskV_-1.0=0.40380511, val_rnn_1_1step_CC_maskV_-1.0=0.67720193, learning_rate=0.001\n", + "Epoch 136/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38136753, rnn_1_1step_R2_maskV_-1.0=0.61251193, rnn_1_1step_CC_maskV_-1.0=0.78654146, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52783662, val_rnn_1_1step_R2_maskV_-1.0=0.38311714, val_rnn_1_1step_CC_maskV_-1.0=0.66870159, learning_rate=0.001\n", + "Epoch 141/141 - loss=rnn_1_1step_loss=0.37312594, rnn_1_1step_R2_maskV_-1.0=0.62083918, rnn_1_1step_CC_maskV_-1.0=0.79174519, rnn_1_1step_MSE_maskV_-1.0=0.37312597, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52528483, val_rnn_1_1step_R2_maskV_-1.0=0.38682622, val_rnn_1_1step_CC_maskV_-1.0=0.66995603, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:27:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 17.49s\n", + "\u001b[32m2025-05-30 11:27:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.49359116)\n", + "\u001b[32m2025-05-30 11:27:17\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.392, R2_maskV_-1.0=0.608, CC_maskV_-1.0=0.781\n", + "\u001b[32m2025-05-30 11:27:17\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.487, R2_maskV_-1.0=0.441, CC_maskV_-1.0=0.701\n", + "\u001b[32m2025-05-30 11:27:17\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:27:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:27:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 122 (stopped at 137 epochs).\n", + "\u001b[32m2025-05-30 11:27:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/138 - loss=1.0314176, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.19588082, MSE_maskV_-1.0=1.0311863, val_loss=0.94414371, val_CC_maskV_-1.0=0.29993594, val_MSE_maskV_-1.0=0.94185293, learning_rate=0.001\n", + "Epoch 15/138 - loss=0.67729801, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56803441, MSE_maskV_-1.0=0.67748141, val_loss=0.7249276, val_CC_maskV_-1.0=0.54557854, val_MSE_maskV_-1.0=0.72282064, learning_rate=0.001\n", + "Epoch 29/138 - loss=0.64902908, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59107149, MSE_maskV_-1.0=0.64868051, val_loss=0.6999048, val_CC_maskV_-1.0=0.56653261, val_MSE_maskV_-1.0=0.69758552, learning_rate=0.001\n", + "Epoch 43/138 - loss=0.63549262, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60224378, MSE_maskV_-1.0=0.635409, val_loss=0.69045949, val_CC_maskV_-1.0=0.5741396, val_MSE_maskV_-1.0=0.68825257, learning_rate=0.001\n", + "Epoch 57/138 - loss=0.6262604, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60905284, MSE_maskV_-1.0=0.62673211, val_loss=0.68297571, val_CC_maskV_-1.0=0.58000427, val_MSE_maskV_-1.0=0.68041307, learning_rate=0.001\n", + "Epoch 71/138 - loss=0.61842149, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61538094, MSE_maskV_-1.0=0.61983258, val_loss=0.67589808, val_CC_maskV_-1.0=0.5869292, val_MSE_maskV_-1.0=0.67386961, learning_rate=0.001\n", + "Epoch 85/138 - loss=0.6126669, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61982942, MSE_maskV_-1.0=0.61279875, val_loss=0.67210579, val_CC_maskV_-1.0=0.58938622, val_MSE_maskV_-1.0=0.66958553, learning_rate=0.001\n", + "Epoch 99/138 - loss=0.60867363, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62301809, MSE_maskV_-1.0=0.60837573, val_loss=0.66502333, val_CC_maskV_-1.0=0.59547681, val_MSE_maskV_-1.0=0.66232651, learning_rate=0.001\n", + "Epoch 113/138 - loss=0.60542089, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62599218, MSE_maskV_-1.0=0.60698724, val_loss=0.66341615, val_CC_maskV_-1.0=0.59573883, val_MSE_maskV_-1.0=0.66114378, learning_rate=0.001\n", + "Epoch 127/138 - loss=0.60199922, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62782711, MSE_maskV_-1.0=0.60336035, val_loss=0.66398275, val_CC_maskV_-1.0=0.59548694, val_MSE_maskV_-1.0=0.66139138, learning_rate=0.001\n", + "Epoch 138/138 - loss=0.59961718, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63043791, MSE_maskV_-1.0=0.59950942, val_loss=0.65953666, val_CC_maskV_-1.0=0.59933484, val_MSE_maskV_-1.0=0.65676051, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:27:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 36.50s\n", + "\u001b[32m2025-05-30 11:27:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:28:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 117 (stopped at 132 epochs).\n", + "\u001b[32m2025-05-30 11:28:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/133 - loss=1.0141339, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.20577596, MSE_maskV_-1.0=1.0140419, val_loss=0.93439138, val_CC_maskV_-1.0=0.31728697, val_MSE_maskV_-1.0=0.93067843, learning_rate=0.001\n", + "Epoch 15/133 - loss=0.67823583, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56709605, MSE_maskV_-1.0=0.67849749, val_loss=0.72725785, val_CC_maskV_-1.0=0.54371023, val_MSE_maskV_-1.0=0.72492129, learning_rate=0.001\n", + "Epoch 29/133 - loss=0.64497918, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59415567, MSE_maskV_-1.0=0.64463621, val_loss=0.69720495, val_CC_maskV_-1.0=0.56930864, val_MSE_maskV_-1.0=0.69497687, learning_rate=0.001\n", + "Epoch 43/133 - loss=0.62983471, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6069048, MSE_maskV_-1.0=0.62975639, val_loss=0.68682241, val_CC_maskV_-1.0=0.5775997, val_MSE_maskV_-1.0=0.68486738, learning_rate=0.001\n", + "Epoch 57/133 - loss=0.62011629, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61396587, MSE_maskV_-1.0=0.62058729, val_loss=0.68000323, val_CC_maskV_-1.0=0.58323956, val_MSE_maskV_-1.0=0.67737854, learning_rate=0.001\n", + "Epoch 71/133 - loss=0.61311179, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61993641, MSE_maskV_-1.0=0.61475569, val_loss=0.67389214, val_CC_maskV_-1.0=0.58864385, val_MSE_maskV_-1.0=0.67205894, learning_rate=0.001\n", + "Epoch 85/133 - loss=0.60726136, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62440753, MSE_maskV_-1.0=0.60741347, val_loss=0.66954362, val_CC_maskV_-1.0=0.59122878, val_MSE_maskV_-1.0=0.66752595, learning_rate=0.001\n", + "Epoch 99/133 - loss=0.60334498, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62760377, MSE_maskV_-1.0=0.60295343, val_loss=0.66471398, val_CC_maskV_-1.0=0.59570658, val_MSE_maskV_-1.0=0.66246289, learning_rate=0.001\n", + "Epoch 113/133 - loss=0.59965569, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6308648, MSE_maskV_-1.0=0.60139972, val_loss=0.66179836, val_CC_maskV_-1.0=0.59720105, val_MSE_maskV_-1.0=0.65980524, learning_rate=0.001\n", + "Epoch 127/133 - loss=0.59642494, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63243079, MSE_maskV_-1.0=0.59778726, val_loss=0.66154188, val_CC_maskV_-1.0=0.59746069, val_MSE_maskV_-1.0=0.65937376, learning_rate=0.001\n", + "Epoch 133/133 - loss=0.59508544, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63411307, MSE_maskV_-1.0=0.59476203, val_loss=0.66204983, val_CC_maskV_-1.0=0.59738177, val_MSE_maskV_-1.0=0.6597712, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:28:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 34.95s\n", + "\u001b[32m2025-05-30 11:28:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.65829355)\n", + "\u001b[32m2025-05-30 11:28:28\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 789us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:28:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.595, R2_maskV_-1.0=0.407, CC_maskV_-1.0=0.637\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 783us/step\n", + "51/51 [==============================] - 0s 819us/step\n", + "84/84 [==============================] - 0s 979us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:28:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_ACy1HL64U_ErSV16\" (8/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_ACy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:28:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_KCz1HL64U_ErSV16\" (9/16)\n", + "\u001b[32m2025-05-30 11:28:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:28:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:28:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:28:30\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:28:30\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:28:30\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:28:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:28:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 108 (stopped at 123 epochs).\n", + "\u001b[32m2025-05-30 11:28:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/124 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0015832, rnn_1step_R2_maskV_-1.0=-0.01425321, rnn_1step_CC_maskV_-1.0=0.012684026, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.9227348, val_rnn_1step_R2_maskV_-1.0=-0.06413509, val_rnn_1step_CC_maskV_-1.0=0.22018886, learning_rate=0.001\n", + "Epoch 14/124 - loss=rnn_1step_loss=0.75311327, rnn_1step_R2_maskV_-1.0=0.23357034, rnn_1step_CC_maskV_-1.0=0.50228012, rnn_1step_MSE_maskV_-1.0=0.75311333, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.72223014, val_rnn_1step_R2_maskV_-1.0=0.16011645, val_rnn_1step_CC_maskV_-1.0=0.47375906, learning_rate=0.001\n", + "Epoch 27/124 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.58014131, rnn_1step_R2_maskV_-1.0=0.40731323, rnn_1step_CC_maskV_-1.0=0.65065837, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62842923, val_rnn_1step_R2_maskV_-1.0=0.26601574, val_rnn_1step_CC_maskV_-1.0=0.57260334, learning_rate=0.001\n", + "Epoch 40/124 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.46916461, rnn_1step_R2_maskV_-1.0=0.52087951, rnn_1step_CC_maskV_-1.0=0.72922373, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57536465, val_rnn_1step_R2_maskV_-1.0=0.33173513, val_rnn_1step_CC_maskV_-1.0=0.6278863, learning_rate=0.001\n", + "Epoch 53/124 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.36902609, rnn_1step_R2_maskV_-1.0=0.62400752, rnn_1step_CC_maskV_-1.0=0.79425937, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52977306, val_rnn_1step_R2_maskV_-1.0=0.38470528, val_rnn_1step_CC_maskV_-1.0=0.66953546, learning_rate=0.001\n", + "Epoch 66/124 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29612932, rnn_1step_R2_maskV_-1.0=0.69953686, rnn_1step_CC_maskV_-1.0=0.83901006, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49130964, val_rnn_1step_R2_maskV_-1.0=0.4272016, val_rnn_1step_CC_maskV_-1.0=0.70275819, learning_rate=0.001\n", + "Epoch 79/124 - loss=rnn_1step_loss=0.25398967, rnn_1step_R2_maskV_-1.0=0.74259692, rnn_1step_CC_maskV_-1.0=0.86381185, rnn_1step_MSE_maskV_-1.0=0.25398964, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47490656, val_rnn_1step_R2_maskV_-1.0=0.44505122, val_rnn_1step_CC_maskV_-1.0=0.71823406, learning_rate=0.001\n", + "Epoch 92/124 - loss=rnn_1step_loss=0.22605926, rnn_1step_R2_maskV_-1.0=0.77088106, rnn_1step_CC_maskV_-1.0=0.87981188, rnn_1step_MSE_maskV_-1.0=0.22605924, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46611014, val_rnn_1step_R2_maskV_-1.0=0.45453456, val_rnn_1step_CC_maskV_-1.0=0.7272988, learning_rate=0.001\n", + "Epoch 105/124 - loss=rnn_1step_loss=0.20836599, rnn_1step_R2_maskV_-1.0=0.78859413, rnn_1step_CC_maskV_-1.0=0.88963312, rnn_1step_MSE_maskV_-1.0=0.20836601, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46652541, val_rnn_1step_R2_maskV_-1.0=0.45538378, val_rnn_1step_CC_maskV_-1.0=0.72774899, learning_rate=0.001\n", + "Epoch 118/124 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.19640698, rnn_1step_R2_maskV_-1.0=0.80060691, rnn_1step_CC_maskV_-1.0=0.89634657, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46546295, val_rnn_1step_R2_maskV_-1.0=0.45549354, val_rnn_1step_CC_maskV_-1.0=0.73026395, learning_rate=0.001\n", + "Epoch 124/124 - loss=rnn_1step_loss=0.19402151, rnn_1step_R2_maskV_-1.0=0.8030293, rnn_1step_CC_maskV_-1.0=0.89736307, rnn_1step_MSE_maskV_-1.0=0.19402152, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46180415, val_rnn_1step_R2_maskV_-1.0=0.46041146, val_rnn_1step_CC_maskV_-1.0=0.73351097, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:28:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.69s\n", + "\u001b[32m2025-05-30 11:28:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:29:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 155 (stopped at 170 epochs).\n", + "\u001b[32m2025-05-30 11:29:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/171 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0015211, rnn_1_1step_R2_maskV_-1.0=-0.014196899, rnn_1_1step_CC_maskV_-1.0=0.035207249, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92297155, val_rnn_1_1step_R2_maskV_-1.0=-0.064398438, val_rnn_1_1step_CC_maskV_-1.0=0.28537455, learning_rate=0.001\n", + "Epoch 19/171 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.64767957, rnn_1_1step_R2_maskV_-1.0=0.33794278, rnn_1_1step_CC_maskV_-1.0=0.59613973, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.66818261, val_rnn_1_1step_R2_maskV_-1.0=0.22323121, val_rnn_1_1step_CC_maskV_-1.0=0.53648454, learning_rate=0.001\n", + "Epoch 37/171 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.51488304, rnn_1_1step_R2_maskV_-1.0=0.47332695, rnn_1_1step_CC_maskV_-1.0=0.69847304, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60634017, val_rnn_1_1step_R2_maskV_-1.0=0.29914507, val_rnn_1_1step_CC_maskV_-1.0=0.59548295, learning_rate=0.001\n", + "Epoch 55/171 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36204353, rnn_1_1step_R2_maskV_-1.0=0.63121903, rnn_1_1step_CC_maskV_-1.0=0.79861814, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52364105, val_rnn_1_1step_R2_maskV_-1.0=0.39112881, val_rnn_1_1step_CC_maskV_-1.0=0.67435765, learning_rate=0.001\n", + "Epoch 73/171 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.29176772, rnn_1_1step_R2_maskV_-1.0=0.70363426, rnn_1_1step_CC_maskV_-1.0=0.84127247, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50753134, val_rnn_1_1step_R2_maskV_-1.0=0.40596902, val_rnn_1_1step_CC_maskV_-1.0=0.69239813, learning_rate=0.001\n", + "Epoch 91/171 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.25173095, rnn_1_1step_R2_maskV_-1.0=0.74477202, rnn_1_1step_CC_maskV_-1.0=0.86475557, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50362998, val_rnn_1_1step_R2_maskV_-1.0=0.41001099, val_rnn_1_1step_CC_maskV_-1.0=0.69932657, learning_rate=0.001\n", + "Epoch 109/171 - loss=rnn_1_1step_loss=0.22396195, rnn_1_1step_R2_maskV_-1.0=0.7729423, rnn_1_1step_CC_maskV_-1.0=0.88087612, rnn_1_1step_MSE_maskV_-1.0=0.22396193, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50079292, val_rnn_1_1step_R2_maskV_-1.0=0.41229805, val_rnn_1_1step_CC_maskV_-1.0=0.70675516, learning_rate=0.001\n", + "Epoch 127/171 - loss=rnn_1_1step_loss=0.20059048, rnn_1_1step_R2_maskV_-1.0=0.79645991, rnn_1_1step_CC_maskV_-1.0=0.89396912, rnn_1_1step_MSE_maskV_-1.0=0.20059046, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48946393, val_rnn_1_1step_R2_maskV_-1.0=0.42661196, val_rnn_1_1step_CC_maskV_-1.0=0.71464646, learning_rate=0.001\n", + "Epoch 145/171 - loss=rnn_1_1step_loss=0.18826, rnn_1_1step_R2_maskV_-1.0=0.80854344, rnn_1_1step_CC_maskV_-1.0=0.90047389, rnn_1_1step_MSE_maskV_-1.0=0.18826002, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46474135, val_rnn_1_1step_R2_maskV_-1.0=0.45716265, val_rnn_1_1step_CC_maskV_-1.0=0.73010266, learning_rate=0.001\n", + "Epoch 163/171 - loss=rnn_1_1step_loss=0.17187195, rnn_1_1step_R2_maskV_-1.0=0.82537305, rnn_1_1step_CC_maskV_-1.0=0.90987396, rnn_1_1step_MSE_maskV_-1.0=0.17187193, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47622526, val_rnn_1_1step_R2_maskV_-1.0=0.44294, val_rnn_1_1step_CC_maskV_-1.0=0.72627032, learning_rate=0.001\n", + "Epoch 171/171 - loss=rnn_1_1step_loss=0.17029701, rnn_1_1step_R2_maskV_-1.0=0.82713485, rnn_1_1step_CC_maskV_-1.0=0.91050029, rnn_1_1step_MSE_maskV_-1.0=0.17029703, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46340716, val_rnn_1_1step_R2_maskV_-1.0=0.45844719, val_rnn_1_1step_CC_maskV_-1.0=0.73166913, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:29:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 19.43s\n", + "\u001b[32m2025-05-30 11:29:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.45709002)\n", + "\u001b[32m2025-05-30 11:29:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.176, R2_maskV_-1.0=0.824, CC_maskV_-1.0=0.908\n", + "\u001b[32m2025-05-30 11:29:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.402, R2_maskV_-1.0=0.539, CC_maskV_-1.0=0.771\n", + "\u001b[32m2025-05-30 11:29:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:29:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:30:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 278 (stopped at 293 epochs).\n", + "\u001b[32m2025-05-30 11:30:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/294 - loss=2.4823341, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.044218935, MSE_maskV_-1.0=2.4783757, val_loss=1.205803, val_CC_maskV_-1.0=0.088458136, val_MSE_maskV_-1.0=1.2047702, learning_rate=0.001\n", + "Epoch 31/294 - loss=0.87229764, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3605015, MSE_maskV_-1.0=0.8725251, val_loss=0.90689027, val_CC_maskV_-1.0=0.35739732, val_MSE_maskV_-1.0=0.90344191, learning_rate=0.001\n", + "Epoch 61/294 - loss=0.84772319, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39419833, MSE_maskV_-1.0=0.84799331, val_loss=0.88054752, val_CC_maskV_-1.0=0.39199165, val_MSE_maskV_-1.0=0.87748384, learning_rate=0.001\n", + "Epoch 91/294 - loss=0.83392054, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41154018, MSE_maskV_-1.0=0.83494395, val_loss=0.86937553, val_CC_maskV_-1.0=0.40406331, val_MSE_maskV_-1.0=0.86644632, learning_rate=0.001\n", + "Epoch 121/294 - loss=0.82547641, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42034689, MSE_maskV_-1.0=0.82524514, val_loss=0.8590225, val_CC_maskV_-1.0=0.41707492, val_MSE_maskV_-1.0=0.85602683, learning_rate=0.001\n", + "Epoch 151/294 - loss=0.8192026, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42806733, MSE_maskV_-1.0=0.8190937, val_loss=0.85478073, val_CC_maskV_-1.0=0.42163742, val_MSE_maskV_-1.0=0.85177386, learning_rate=0.001\n", + "Epoch 181/294 - loss=0.81403226, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43318176, MSE_maskV_-1.0=0.81394494, val_loss=0.8499729, val_CC_maskV_-1.0=0.42612249, val_MSE_maskV_-1.0=0.84730124, learning_rate=0.001\n", + "Epoch 211/294 - loss=0.80951196, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43908632, MSE_maskV_-1.0=0.80888623, val_loss=0.84564358, val_CC_maskV_-1.0=0.43090728, val_MSE_maskV_-1.0=0.84286582, learning_rate=0.001\n", + "Epoch 241/294 - loss=0.80618775, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44247121, MSE_maskV_-1.0=0.80548292, val_loss=0.8443982, val_CC_maskV_-1.0=0.43268275, val_MSE_maskV_-1.0=0.84144074, learning_rate=0.001\n", + "Epoch 271/294 - loss=0.80342066, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44539744, MSE_maskV_-1.0=0.80302447, val_loss=0.84511644, val_CC_maskV_-1.0=0.43210879, val_MSE_maskV_-1.0=0.84188217, learning_rate=0.001\n", + "Epoch 294/294 - loss=0.80149812, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44772327, MSE_maskV_-1.0=0.80134308, val_loss=0.84099615, val_CC_maskV_-1.0=0.43612453, val_MSE_maskV_-1.0=0.83791822, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:30:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 70.92s\n", + "\u001b[32m2025-05-30 11:30:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:31:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 278 (stopped at 293 epochs).\n", + "\u001b[32m2025-05-30 11:31:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/294 - loss=2.7163615, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=-0.0015752169, MSE_maskV_-1.0=2.7123809, val_loss=1.2435708, val_CC_maskV_-1.0=0.046009559, val_MSE_maskV_-1.0=1.242285, learning_rate=0.001\n", + "Epoch 31/294 - loss=0.87520534, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35589918, MSE_maskV_-1.0=0.87539947, val_loss=0.91045737, val_CC_maskV_-1.0=0.35152426, val_MSE_maskV_-1.0=0.9068073, learning_rate=0.001\n", + "Epoch 61/294 - loss=0.85018748, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3907207, MSE_maskV_-1.0=0.85044664, val_loss=0.8835535, val_CC_maskV_-1.0=0.38767341, val_MSE_maskV_-1.0=0.88025713, learning_rate=0.001\n", + "Epoch 91/294 - loss=0.83585489, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40892416, MSE_maskV_-1.0=0.83688605, val_loss=0.87165427, val_CC_maskV_-1.0=0.40103719, val_MSE_maskV_-1.0=0.86854428, learning_rate=0.001\n", + "Epoch 121/294 - loss=0.82704067, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41836745, MSE_maskV_-1.0=0.82680196, val_loss=0.86083239, val_CC_maskV_-1.0=0.41469353, val_MSE_maskV_-1.0=0.85769409, learning_rate=0.001\n", + "Epoch 151/294 - loss=0.82049537, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42650023, MSE_maskV_-1.0=0.8203876, val_loss=0.8562429, val_CC_maskV_-1.0=0.41986099, val_MSE_maskV_-1.0=0.85309225, learning_rate=0.001\n", + "Epoch 181/294 - loss=0.81511134, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43190402, MSE_maskV_-1.0=0.81502205, val_loss=0.85124451, val_CC_maskV_-1.0=0.42460909, val_MSE_maskV_-1.0=0.84844875, learning_rate=0.001\n", + "Epoch 211/294 - loss=0.8104372, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43799701, MSE_maskV_-1.0=0.80980939, val_loss=0.84664631, val_CC_maskV_-1.0=0.42974448, val_MSE_maskV_-1.0=0.84375387, learning_rate=0.001\n", + "Epoch 241/294 - loss=0.80701256, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44155154, MSE_maskV_-1.0=0.80630225, val_loss=0.8452661, val_CC_maskV_-1.0=0.4316957, val_MSE_maskV_-1.0=0.84221035, learning_rate=0.001\n", + "Epoch 271/294 - loss=0.804115, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44460058, MSE_maskV_-1.0=0.80372483, val_loss=0.84589523, val_CC_maskV_-1.0=0.43123618, val_MSE_maskV_-1.0=0.84256768, learning_rate=0.001\n", + "Epoch 294/294 - loss=0.80213177, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44699273, MSE_maskV_-1.0=0.80197924, val_loss=0.84168243, val_CC_maskV_-1.0=0.43532786, val_MSE_maskV_-1.0=0.83852327, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:31:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 71.68s\n", + "\u001b[32m2025-05-30 11:31:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.83919728)\n", + "\u001b[32m2025-05-30 11:31:28\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 698us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:31:28\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.801, R2_maskV_-1.0=0.198, CC_maskV_-1.0=0.448\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 753us/step\n", + "51/51 [==============================] - 0s 800us/step\n", + "84/84 [==============================] - 0s 709us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:31:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_KCz1HL64U_ErSV16\" (9/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_KCz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:31:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_KCy1HL64U_ErSV16\" (10/16)\n", + "\u001b[32m2025-05-30 11:31:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:31:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:31:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:31:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:31:29\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:31:29\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:31:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:31:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 69 (stopped at 84 epochs).\n", + "\u001b[32m2025-05-30 11:31:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/85 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0010653, rnn_1step_R2_maskV_-1.0=-0.013704307, rnn_1step_CC_maskV_-1.0=0.081085376, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92262053, val_rnn_1step_R2_maskV_-1.0=-0.064081401, val_rnn_1step_CC_maskV_-1.0=0.2158217, learning_rate=0.001\n", + "Epoch 10/85 - loss=rnn_1step_loss=0.84984827, rnn_1step_R2_maskV_-1.0=0.13951315, rnn_1step_CC_maskV_-1.0=0.41436982, rnn_1step_MSE_maskV_-1.0=0.84984833, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.78887272, val_rnn_1step_R2_maskV_-1.0=0.080876306, val_rnn_1step_CC_maskV_-1.0=0.3855941, learning_rate=0.001\n", + "Epoch 19/85 - loss=rnn_1step_loss=0.62615019, rnn_1step_R2_maskV_-1.0=0.36433488, rnn_1step_CC_maskV_-1.0=0.61360061, rnn_1step_MSE_maskV_-1.0=0.62615025, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.65264064, val_rnn_1step_R2_maskV_-1.0=0.23971602, val_rnn_1step_CC_maskV_-1.0=0.55110717, learning_rate=0.001\n", + "Epoch 28/85 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.49570373, rnn_1step_R2_maskV_-1.0=0.49638009, rnn_1step_CC_maskV_-1.0=0.70962, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56120181, val_rnn_1step_R2_maskV_-1.0=0.34505272, val_rnn_1step_CC_maskV_-1.0=0.6392526, learning_rate=0.001\n", + "Epoch 37/85 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40648198, rnn_1step_R2_maskV_-1.0=0.58786547, rnn_1step_CC_maskV_-1.0=0.77033985, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49888673, val_rnn_1step_R2_maskV_-1.0=0.41461241, val_rnn_1step_CC_maskV_-1.0=0.689542, learning_rate=0.001\n", + "Epoch 46/85 - loss=rnn_1step_loss=0.36897555, rnn_1step_R2_maskV_-1.0=0.62596828, rnn_1step_CC_maskV_-1.0=0.79435629, rnn_1step_MSE_maskV_-1.0=0.36897558, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49667725, val_rnn_1step_R2_maskV_-1.0=0.41770422, val_rnn_1step_CC_maskV_-1.0=0.69144839, learning_rate=0.001\n", + "Epoch 55/85 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3361775, rnn_1step_R2_maskV_-1.0=0.65936077, rnn_1step_CC_maskV_-1.0=0.81475437, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48683324, val_rnn_1step_R2_maskV_-1.0=0.4295747, val_rnn_1step_CC_maskV_-1.0=0.69976711, learning_rate=0.001\n", + "Epoch 64/85 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30102444, rnn_1step_R2_maskV_-1.0=0.6953392, rnn_1step_CC_maskV_-1.0=0.83584237, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46920022, val_rnn_1step_R2_maskV_-1.0=0.44983953, val_rnn_1step_CC_maskV_-1.0=0.71478224, learning_rate=0.001\n", + "Epoch 73/85 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27628717, rnn_1step_R2_maskV_-1.0=0.7204628, rnn_1step_CC_maskV_-1.0=0.850299, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46738222, val_rnn_1step_R2_maskV_-1.0=0.45175508, val_rnn_1step_CC_maskV_-1.0=0.72027439, learning_rate=0.001\n", + "Epoch 82/85 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.25907099, rnn_1step_R2_maskV_-1.0=0.73788124, rnn_1step_CC_maskV_-1.0=0.86032033, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47124162, val_rnn_1step_R2_maskV_-1.0=0.44718003, val_rnn_1step_CC_maskV_-1.0=0.72074586, learning_rate=0.001\n", + "Epoch 85/85 - loss=rnn_1step_loss=0.25461748, rnn_1step_R2_maskV_-1.0=0.74244988, rnn_1step_CC_maskV_-1.0=0.86289334, rnn_1step_MSE_maskV_-1.0=0.25461751, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46892068, val_rnn_1step_R2_maskV_-1.0=0.44969308, val_rnn_1step_CC_maskV_-1.0=0.72235608, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:31:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 11.24s\n", + "\u001b[32m2025-05-30 11:31:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:31:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 66 (stopped at 81 epochs).\n", + "\u001b[32m2025-05-30 11:31:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/82 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0006213, rnn_1_1step_R2_maskV_-1.0=-0.013243914, rnn_1_1step_CC_maskV_-1.0=0.11192165, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92073947, val_rnn_1_1step_R2_maskV_-1.0=-0.0618705, val_rnn_1_1step_CC_maskV_-1.0=0.29370591, learning_rate=0.001\n", + "Epoch 10/82 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.85946751, rnn_1_1step_R2_maskV_-1.0=0.12958124, rnn_1_1step_CC_maskV_-1.0=0.43084416, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.77086514, val_rnn_1_1step_R2_maskV_-1.0=0.10683548, val_rnn_1_1step_CC_maskV_-1.0=0.42478967, learning_rate=0.001\n", + "Epoch 19/82 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.62030154, rnn_1_1step_R2_maskV_-1.0=0.36976057, rnn_1_1step_CC_maskV_-1.0=0.61816514, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62735873, val_rnn_1_1step_R2_maskV_-1.0=0.26623788, val_rnn_1_1step_CC_maskV_-1.0=0.57863986, learning_rate=0.001\n", + "Epoch 28/82 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.4843525, rnn_1_1step_R2_maskV_-1.0=0.50811702, rnn_1_1step_CC_maskV_-1.0=0.71827322, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55474669, val_rnn_1_1step_R2_maskV_-1.0=0.35017076, val_rnn_1_1step_CC_maskV_-1.0=0.65051448, learning_rate=0.001\n", + "Epoch 37/82 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40299621, rnn_1_1step_R2_maskV_-1.0=0.59168279, rnn_1_1step_CC_maskV_-1.0=0.77249563, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50134188, val_rnn_1_1step_R2_maskV_-1.0=0.41228724, val_rnn_1_1step_CC_maskV_-1.0=0.69002914, learning_rate=0.001\n", + "Epoch 46/82 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.35945377, rnn_1_1step_R2_maskV_-1.0=0.63565844, rnn_1_1step_CC_maskV_-1.0=0.80050337, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4924053, val_rnn_1_1step_R2_maskV_-1.0=0.42367333, val_rnn_1_1step_CC_maskV_-1.0=0.69740373, learning_rate=0.001\n", + "Epoch 55/82 - loss=rnn_1_1step_loss=0.32301834, rnn_1_1step_R2_maskV_-1.0=0.67298126, rnn_1_1step_CC_maskV_-1.0=0.82306081, rnn_1_1step_MSE_maskV_-1.0=0.32301837, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47810864, val_rnn_1_1step_R2_maskV_-1.0=0.44042206, val_rnn_1_1step_CC_maskV_-1.0=0.70860142, learning_rate=0.001\n", + "Epoch 64/82 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.28949839, rnn_1_1step_R2_maskV_-1.0=0.70757186, rnn_1_1step_CC_maskV_-1.0=0.84291375, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46365523, val_rnn_1_1step_R2_maskV_-1.0=0.45674312, val_rnn_1_1step_CC_maskV_-1.0=0.72141272, learning_rate=0.001\n", + "Epoch 73/82 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.26755646, rnn_1_1step_R2_maskV_-1.0=0.72996712, rnn_1_1step_CC_maskV_-1.0=0.85565996, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46544588, val_rnn_1_1step_R2_maskV_-1.0=0.45492408, val_rnn_1_1step_CC_maskV_-1.0=0.72305286, learning_rate=0.001\n", + "Epoch 82/82 - loss=rnn_1_1step_loss=0.25246242, rnn_1_1step_R2_maskV_-1.0=0.74525201, rnn_1_1step_CC_maskV_-1.0=0.86440253, rnn_1_1step_MSE_maskV_-1.0=0.25246245, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46735176, val_rnn_1_1step_R2_maskV_-1.0=0.45287758, val_rnn_1_1step_CC_maskV_-1.0=0.72377825, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:31:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 9.66s\n", + "\u001b[32m2025-05-30 11:31:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.46342221)\n", + "\u001b[32m2025-05-30 11:31:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.249, R2_maskV_-1.0=0.751, CC_maskV_-1.0=0.866\n", + "\u001b[32m2025-05-30 11:31:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.433, R2_maskV_-1.0=0.504, CC_maskV_-1.0=0.746\n", + "\u001b[32m2025-05-30 11:31:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:31:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:32:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 180 (stopped at 195 epochs).\n", + "\u001b[32m2025-05-30 11:32:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/196 - loss=1.0303131, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.16913423, MSE_maskV_-1.0=1.030411, val_loss=0.97527456, val_CC_maskV_-1.0=0.24347737, val_MSE_maskV_-1.0=0.97169226, learning_rate=0.001\n", + "Epoch 21/196 - loss=0.816553, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42977864, MSE_maskV_-1.0=0.81643671, val_loss=0.86858332, val_CC_maskV_-1.0=0.4055717, val_MSE_maskV_-1.0=0.86528188, learning_rate=0.001\n", + "Epoch 41/196 - loss=0.77855772, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47164053, MSE_maskV_-1.0=0.77902895, val_loss=0.8386991, val_CC_maskV_-1.0=0.43970007, val_MSE_maskV_-1.0=0.83518505, learning_rate=0.001\n", + "Epoch 61/196 - loss=0.76011902, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49130434, MSE_maskV_-1.0=0.76027364, val_loss=0.82046068, val_CC_maskV_-1.0=0.4605273, val_MSE_maskV_-1.0=0.81651336, learning_rate=0.001\n", + "Epoch 81/196 - loss=0.74928552, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50140065, MSE_maskV_-1.0=0.74998313, val_loss=0.81192386, val_CC_maskV_-1.0=0.46826074, val_MSE_maskV_-1.0=0.80858946, learning_rate=0.001\n", + "Epoch 101/196 - loss=0.74134177, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.509404, MSE_maskV_-1.0=0.74065357, val_loss=0.80454153, val_CC_maskV_-1.0=0.47583613, val_MSE_maskV_-1.0=0.80077606, learning_rate=0.001\n", + "Epoch 121/196 - loss=0.73564523, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51422036, MSE_maskV_-1.0=0.73557842, val_loss=0.80017561, val_CC_maskV_-1.0=0.48023912, val_MSE_maskV_-1.0=0.79627824, learning_rate=0.001\n", + "Epoch 141/196 - loss=0.73073632, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51946294, MSE_maskV_-1.0=0.73254335, val_loss=0.7987116, val_CC_maskV_-1.0=0.48144263, val_MSE_maskV_-1.0=0.79502404, learning_rate=0.001\n", + "Epoch 161/196 - loss=0.72630942, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52303946, MSE_maskV_-1.0=0.72649395, val_loss=0.79430878, val_CC_maskV_-1.0=0.48574492, val_MSE_maskV_-1.0=0.79090053, learning_rate=0.001\n", + "Epoch 181/196 - loss=0.72374141, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52543622, MSE_maskV_-1.0=0.72356075, val_loss=0.79195517, val_CC_maskV_-1.0=0.48769215, val_MSE_maskV_-1.0=0.78849137, learning_rate=0.001\n", + "Epoch 196/196 - loss=0.72179043, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5268259, MSE_maskV_-1.0=0.72115529, val_loss=0.79751563, val_CC_maskV_-1.0=0.48386094, val_MSE_maskV_-1.0=0.79391325, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:32:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 51.62s\n", + "\u001b[32m2025-05-30 11:32:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:33:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 130 (stopped at 145 epochs).\n", + "\u001b[32m2025-05-30 11:33:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/146 - loss=1.0201567, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.1635288, MSE_maskV_-1.0=1.0202616, val_loss=0.97968692, val_CC_maskV_-1.0=0.23456725, val_MSE_maskV_-1.0=0.97639728, learning_rate=0.001\n", + "Epoch 16/146 - loss=0.82735687, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41765124, MSE_maskV_-1.0=0.82770032, val_loss=0.8774848, val_CC_maskV_-1.0=0.3970426, val_MSE_maskV_-1.0=0.8736397, learning_rate=0.001\n", + "Epoch 31/146 - loss=0.78844279, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46168283, MSE_maskV_-1.0=0.78859037, val_loss=0.84740734, val_CC_maskV_-1.0=0.43077853, val_MSE_maskV_-1.0=0.84359878, learning_rate=0.001\n", + "Epoch 46/146 - loss=0.76998115, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48058167, MSE_maskV_-1.0=0.77016908, val_loss=0.82863569, val_CC_maskV_-1.0=0.45150384, val_MSE_maskV_-1.0=0.8247214, learning_rate=0.001\n", + "Epoch 61/146 - loss=0.75719708, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49428514, MSE_maskV_-1.0=0.75733149, val_loss=0.81817526, val_CC_maskV_-1.0=0.46283302, val_MSE_maskV_-1.0=0.81400895, learning_rate=0.001\n", + "Epoch 76/146 - loss=0.74901772, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50202507, MSE_maskV_-1.0=0.74866611, val_loss=0.81495887, val_CC_maskV_-1.0=0.46583235, val_MSE_maskV_-1.0=0.8109504, learning_rate=0.001\n", + "Epoch 91/146 - loss=0.74216908, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50853974, MSE_maskV_-1.0=0.74321771, val_loss=0.80491757, val_CC_maskV_-1.0=0.47469854, val_MSE_maskV_-1.0=0.80109197, learning_rate=0.001\n", + "Epoch 106/146 - loss=0.73829299, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51226282, MSE_maskV_-1.0=0.73812777, val_loss=0.80432695, val_CC_maskV_-1.0=0.47699913, val_MSE_maskV_-1.0=0.80028796, learning_rate=0.001\n", + "Epoch 121/146 - loss=0.73437887, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51527399, MSE_maskV_-1.0=0.73430312, val_loss=0.80086291, val_CC_maskV_-1.0=0.48001975, val_MSE_maskV_-1.0=0.79670542, learning_rate=0.001\n", + "Epoch 136/146 - loss=0.73130935, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51899129, MSE_maskV_-1.0=0.73165804, val_loss=0.79815578, val_CC_maskV_-1.0=0.48276001, val_MSE_maskV_-1.0=0.79410607, learning_rate=0.001\n", + "Epoch 146/146 - loss=0.72861999, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52135569, MSE_maskV_-1.0=0.72829175, val_loss=0.80014843, val_CC_maskV_-1.0=0.48127729, val_MSE_maskV_-1.0=0.79585028, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:33:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 38.56s\n", + "\u001b[32m2025-05-30 11:33:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.78988004)\n", + "\u001b[32m2025-05-30 11:33:22\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 854us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:33:22\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.72, R2_maskV_-1.0=0.279, CC_maskV_-1.0=0.529\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 815us/step\n", + "51/51 [==============================] - 0s 815us/step\n", + "84/84 [==============================] - 0s 725us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:33:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_KCy1HL64U_ErSV16\" (10/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_KCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:33:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_CzCy1HL64U_ErSV16\" (11/16)\n", + "\u001b[32m2025-05-30 11:33:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_CzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:33:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:33:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:33:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:33:23\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:33:23\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:33:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:33:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 211 (stopped at 226 epochs).\n", + "\u001b[32m2025-05-30 11:33:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/227 - loss=rnn_1step_loss=1.0010387, rnn_1step_R2_maskV_-1.0=-0.013684303, rnn_1step_CC_maskV_-1.0=0.077202126, rnn_1step_MSE_maskV_-1.0=1.0010388, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92069298, val_rnn_1step_R2_maskV_-1.0=-0.061753184, val_rnn_1step_CC_maskV_-1.0=0.31317893, learning_rate=0.001\n", + "Epoch 24/227 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.60478181, rnn_1step_R2_maskV_-1.0=0.38604546, rnn_1step_CC_maskV_-1.0=0.6302669, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62818652, val_rnn_1step_R2_maskV_-1.0=0.26414925, val_rnn_1step_CC_maskV_-1.0=0.57874078, learning_rate=0.001\n", + "Epoch 47/227 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42699257, rnn_1step_R2_maskV_-1.0=0.566199, rnn_1step_CC_maskV_-1.0=0.75669408, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53371471, val_rnn_1step_R2_maskV_-1.0=0.3754276, val_rnn_1step_CC_maskV_-1.0=0.66798806, learning_rate=0.001\n", + "Epoch 70/227 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37086546, rnn_1step_R2_maskV_-1.0=0.62311518, rnn_1step_CC_maskV_-1.0=0.79313564, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49901143, val_rnn_1step_R2_maskV_-1.0=0.41571301, val_rnn_1step_CC_maskV_-1.0=0.6930908, learning_rate=0.001\n", + "Epoch 93/227 - loss=rnn_1step_loss=0.34744763, rnn_1step_R2_maskV_-1.0=0.64686775, rnn_1step_CC_maskV_-1.0=0.80759501, rnn_1step_MSE_maskV_-1.0=0.3474476, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48532295, val_rnn_1step_R2_maskV_-1.0=0.43095484, val_rnn_1step_CC_maskV_-1.0=0.70765173, learning_rate=0.001\n", + "Epoch 116/227 - loss=rnn_1step_loss=0.33755621, rnn_1step_R2_maskV_-1.0=0.65682089, rnn_1step_CC_maskV_-1.0=0.81368744, rnn_1step_MSE_maskV_-1.0=0.33755624, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4800168, val_rnn_1step_R2_maskV_-1.0=0.43673083, val_rnn_1step_CC_maskV_-1.0=0.71201116, learning_rate=0.001\n", + "Epoch 139/227 - loss=rnn_1step_loss=0.33001715, rnn_1step_R2_maskV_-1.0=0.66446573, rnn_1step_CC_maskV_-1.0=0.81826532, rnn_1step_MSE_maskV_-1.0=0.33001718, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47728753, val_rnn_1step_R2_maskV_-1.0=0.43953454, val_rnn_1step_CC_maskV_-1.0=0.71469426, learning_rate=0.001\n", + "Epoch 162/227 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32309783, rnn_1step_R2_maskV_-1.0=0.67148888, rnn_1step_CC_maskV_-1.0=0.82245505, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47464135, val_rnn_1step_R2_maskV_-1.0=0.44258481, val_rnn_1step_CC_maskV_-1.0=0.71665907, learning_rate=0.001\n", + "Epoch 185/227 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31725928, rnn_1step_R2_maskV_-1.0=0.67744076, rnn_1step_CC_maskV_-1.0=0.82595807, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47509399, val_rnn_1step_R2_maskV_-1.0=0.44232094, val_rnn_1step_CC_maskV_-1.0=0.7174716, learning_rate=0.001\n", + "Epoch 208/227 - loss=rnn_1step_loss=0.31272241, rnn_1step_R2_maskV_-1.0=0.68205994, rnn_1step_CC_maskV_-1.0=0.82869315, rnn_1step_MSE_maskV_-1.0=0.31272238, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47477317, val_rnn_1step_R2_maskV_-1.0=0.44283122, val_rnn_1step_CC_maskV_-1.0=0.71894252, learning_rate=0.001\n", + "Epoch 227/227 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30973443, rnn_1step_R2_maskV_-1.0=0.68508261, rnn_1step_CC_maskV_-1.0=0.83045834, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47324634, val_rnn_1step_R2_maskV_-1.0=0.44469145, val_rnn_1step_CC_maskV_-1.0=0.71979564, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:33:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 22.90s\n", + "\u001b[32m2025-05-30 11:33:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:34:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 274 (stopped at 289 epochs).\n", + "\u001b[32m2025-05-30 11:34:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/290 - loss=rnn_1_1step_loss=1.001017, rnn_1_1step_R2_maskV_-1.0=-0.013700128, rnn_1_1step_CC_maskV_-1.0=0.069749333, rnn_1_1step_MSE_maskV_-1.0=1.0010169, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92100692, val_rnn_1_1step_R2_maskV_-1.0=-0.062034994, val_rnn_1_1step_CC_maskV_-1.0=0.26684693, learning_rate=0.001\n", + "Epoch 30/290 - loss=rnn_1_1step_loss=0.60979146, rnn_1_1step_R2_maskV_-1.0=0.37868434, rnn_1_1step_CC_maskV_-1.0=0.62614793, rnn_1_1step_MSE_maskV_-1.0=0.6097914, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65734798, val_rnn_1_1step_R2_maskV_-1.0=0.23452336, val_rnn_1_1step_CC_maskV_-1.0=0.54811656, learning_rate=0.001\n", + "Epoch 59/290 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.4283298, rnn_1_1step_R2_maskV_-1.0=0.56376404, rnn_1_1step_CC_maskV_-1.0=0.75610882, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54909867, val_rnn_1_1step_R2_maskV_-1.0=0.35922861, val_rnn_1_1step_CC_maskV_-1.0=0.65209103, learning_rate=0.001\n", + "Epoch 88/290 - loss=rnn_1_1step_loss=0.35649475, rnn_1_1step_R2_maskV_-1.0=0.63733339, rnn_1_1step_CC_maskV_-1.0=0.8020013, rnn_1_1step_MSE_maskV_-1.0=0.35649469, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48769772, val_rnn_1_1step_R2_maskV_-1.0=0.42746508, val_rnn_1_1step_CC_maskV_-1.0=0.70186567, learning_rate=0.001\n", + "Epoch 117/290 - loss=rnn_1_1step_loss=0.33200669, rnn_1_1step_R2_maskV_-1.0=0.66240287, rnn_1_1step_CC_maskV_-1.0=0.81697154, rnn_1_1step_MSE_maskV_-1.0=0.33200672, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46764544, val_rnn_1_1step_R2_maskV_-1.0=0.45056933, val_rnn_1_1step_CC_maskV_-1.0=0.71972233, learning_rate=0.001\n", + "Epoch 146/290 - loss=rnn_1_1step_loss=0.32200935, rnn_1_1step_R2_maskV_-1.0=0.67264259, rnn_1_1step_CC_maskV_-1.0=0.82311296, rnn_1_1step_MSE_maskV_-1.0=0.32200938, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46512258, val_rnn_1_1step_R2_maskV_-1.0=0.45391086, val_rnn_1_1step_CC_maskV_-1.0=0.72330701, learning_rate=0.001\n", + "Epoch 175/290 - loss=rnn_1_1step_loss=0.31571326, rnn_1_1step_R2_maskV_-1.0=0.67906171, rnn_1_1step_CC_maskV_-1.0=0.82686287, rnn_1_1step_MSE_maskV_-1.0=0.31571323, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46210369, val_rnn_1_1step_R2_maskV_-1.0=0.45779598, val_rnn_1_1step_CC_maskV_-1.0=0.7265836, learning_rate=0.001\n", + "Epoch 204/290 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30954105, rnn_1_1step_R2_maskV_-1.0=0.68533224, rnn_1_1step_CC_maskV_-1.0=0.83066863, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46080387, val_rnn_1_1step_R2_maskV_-1.0=0.45982009, val_rnn_1_1step_CC_maskV_-1.0=0.72790265, learning_rate=0.001\n", + "Epoch 233/290 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30599222, rnn_1_1step_R2_maskV_-1.0=0.68893927, rnn_1_1step_CC_maskV_-1.0=0.8327654, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45651916, val_rnn_1_1step_R2_maskV_-1.0=0.46494448, val_rnn_1_1step_CC_maskV_-1.0=0.73009336, learning_rate=0.001\n", + "Epoch 262/290 - loss=rnn_1_1step_loss=0.30117229, rnn_1_1step_R2_maskV_-1.0=0.69389343, rnn_1_1step_CC_maskV_-1.0=0.83562523, rnn_1_1step_MSE_maskV_-1.0=0.30117232, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45990571, val_rnn_1_1step_R2_maskV_-1.0=0.46168661, val_rnn_1_1step_CC_maskV_-1.0=0.729922, learning_rate=0.001\n", + "Epoch 290/290 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.29641449, rnn_1_1step_R2_maskV_-1.0=0.6986829, rnn_1_1step_CC_maskV_-1.0=0.83846831, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45231906, val_rnn_1_1step_R2_maskV_-1.0=0.4707759, val_rnn_1_1step_CC_maskV_-1.0=0.7337845, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:34:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 29.11s\n", + "\u001b[32m2025-05-30 11:34:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.45216414)\n", + "\u001b[32m2025-05-30 11:34:17\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.272, R2_maskV_-1.0=0.727, CC_maskV_-1.0=0.853\n", + "\u001b[32m2025-05-30 11:34:17\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.417, R2_maskV_-1.0=0.521, CC_maskV_-1.0=0.763\n", + "\u001b[32m2025-05-30 11:34:17\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:34:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:35:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 172 (stopped at 187 epochs).\n", + "\u001b[32m2025-05-30 11:35:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/188 - loss=3.683253, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.045904052, MSE_maskV_-1.0=3.675313, val_loss=1.2661191, val_CC_maskV_-1.0=0.093054779, val_MSE_maskV_-1.0=1.2631266, learning_rate=0.001\n", + "Epoch 20/188 - loss=0.76333326, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48718405, MSE_maskV_-1.0=0.7631529, val_loss=0.8150726, val_CC_maskV_-1.0=0.46258986, val_MSE_maskV_-1.0=0.81318408, learning_rate=0.001\n", + "Epoch 39/188 - loss=0.68568951, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55995303, MSE_maskV_-1.0=0.68534273, val_loss=0.73287851, val_CC_maskV_-1.0=0.5388096, val_MSE_maskV_-1.0=0.73129636, learning_rate=0.001\n", + "Epoch 58/188 - loss=0.6555931, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58542144, MSE_maskV_-1.0=0.65508199, val_loss=0.70856011, val_CC_maskV_-1.0=0.55947548, val_MSE_maskV_-1.0=0.70722026, learning_rate=0.001\n", + "Epoch 77/188 - loss=0.64113748, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5970912, MSE_maskV_-1.0=0.64074099, val_loss=0.70581907, val_CC_maskV_-1.0=0.56187594, val_MSE_maskV_-1.0=0.70449275, learning_rate=0.001\n", + "Epoch 96/188 - loss=0.63445097, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60145837, MSE_maskV_-1.0=0.63385361, val_loss=0.69191784, val_CC_maskV_-1.0=0.57268685, val_MSE_maskV_-1.0=0.69093126, learning_rate=0.001\n", + "Epoch 115/188 - loss=0.62761694, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60860109, MSE_maskV_-1.0=0.62749761, val_loss=0.68576187, val_CC_maskV_-1.0=0.57699484, val_MSE_maskV_-1.0=0.68468142, learning_rate=0.001\n", + "Epoch 134/188 - loss=0.62588125, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60974407, MSE_maskV_-1.0=0.62613213, val_loss=0.69188392, val_CC_maskV_-1.0=0.57296807, val_MSE_maskV_-1.0=0.69074202, learning_rate=0.001\n", + "Epoch 153/188 - loss=0.62225342, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61242014, MSE_maskV_-1.0=0.62191087, val_loss=0.6781615, val_CC_maskV_-1.0=0.5823195, val_MSE_maskV_-1.0=0.6770758, learning_rate=0.001\n", + "Epoch 172/188 - loss=0.62088633, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61408252, MSE_maskV_-1.0=0.62060356, val_loss=0.6758973, val_CC_maskV_-1.0=0.58374876, val_MSE_maskV_-1.0=0.67471498, learning_rate=0.001\n", + "Epoch 188/188 - loss=0.61764193, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61628705, MSE_maskV_-1.0=0.61703402, val_loss=0.67785531, val_CC_maskV_-1.0=0.5830428, val_MSE_maskV_-1.0=0.67673838, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:35:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 49.48s\n", + "\u001b[32m2025-05-30 11:35:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:35:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 141 (stopped at 156 epochs).\n", + "\u001b[32m2025-05-30 11:35:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/157 - loss=3.6056585, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.046248555, MSE_maskV_-1.0=3.5980456, val_loss=1.3252369, val_CC_maskV_-1.0=0.087835394, val_MSE_maskV_-1.0=1.3225399, learning_rate=0.001\n", + "Epoch 17/157 - loss=0.77338207, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47648966, MSE_maskV_-1.0=0.77320284, val_loss=0.82373375, val_CC_maskV_-1.0=0.45758888, val_MSE_maskV_-1.0=0.82114011, learning_rate=0.001\n", + "Epoch 33/157 - loss=0.70148873, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54572815, MSE_maskV_-1.0=0.70113713, val_loss=0.74956244, val_CC_maskV_-1.0=0.52743202, val_MSE_maskV_-1.0=0.74721128, learning_rate=0.001\n", + "Epoch 49/157 - loss=0.66752017, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57562876, MSE_maskV_-1.0=0.66734147, val_loss=0.72242355, val_CC_maskV_-1.0=0.5504086, val_MSE_maskV_-1.0=0.7207132, learning_rate=0.001\n", + "Epoch 65/157 - loss=0.64970273, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58974099, MSE_maskV_-1.0=0.64898998, val_loss=0.7058593, val_CC_maskV_-1.0=0.56342661, val_MSE_maskV_-1.0=0.70436072, learning_rate=0.001\n", + "Epoch 81/157 - loss=0.6409148, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59818965, MSE_maskV_-1.0=0.64092374, val_loss=0.70131117, val_CC_maskV_-1.0=0.56563765, val_MSE_maskV_-1.0=0.70046645, learning_rate=0.001\n", + "Epoch 97/157 - loss=0.63455576, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60300553, MSE_maskV_-1.0=0.63431138, val_loss=0.69748187, val_CC_maskV_-1.0=0.56846964, val_MSE_maskV_-1.0=0.69679439, learning_rate=0.001\n", + "Epoch 113/157 - loss=0.63040793, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60597807, MSE_maskV_-1.0=0.63234371, val_loss=0.69689202, val_CC_maskV_-1.0=0.56719977, val_MSE_maskV_-1.0=0.69630718, learning_rate=0.001\n", + "Epoch 129/157 - loss=0.62702942, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60826069, MSE_maskV_-1.0=0.62711918, val_loss=0.69018894, val_CC_maskV_-1.0=0.57213962, val_MSE_maskV_-1.0=0.68993938, learning_rate=0.001\n", + "Epoch 145/157 - loss=0.62374783, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61080754, MSE_maskV_-1.0=0.62405092, val_loss=0.68844473, val_CC_maskV_-1.0=0.57526797, val_MSE_maskV_-1.0=0.68824583, learning_rate=0.001\n", + "Epoch 157/157 - loss=0.62369817, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61134177, MSE_maskV_-1.0=0.62340635, val_loss=0.69098437, val_CC_maskV_-1.0=0.57295948, val_MSE_maskV_-1.0=0.69102061, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:35:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 41.96s\n", + "\u001b[32m2025-05-30 11:35:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.6758973)\n", + "\u001b[32m2025-05-30 11:35:48\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 792us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:35:49\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.612, R2_maskV_-1.0=0.389, CC_maskV_-1.0=0.623\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 810us/step\n", + "51/51 [==============================] - 0s 828us/step\n", + "84/84 [==============================] - 0s 697us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:35:49\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_CzCy1HL64U_ErSV16\" (11/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_CzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:35:49\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_uAKCz1HL64U_ErSV16\" (12/16)\n", + "\u001b[32m2025-05-30 11:35:49\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:35:49\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:35:50\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:35:50\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:35:50\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:35:50\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:35:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:36:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 113 (stopped at 128 epochs).\n", + "\u001b[32m2025-05-30 11:36:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/129 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0014806, rnn_1step_R2_maskV_-1.0=-0.014143903, rnn_1step_CC_maskV_-1.0=0.037740979, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92281723, val_rnn_1step_R2_maskV_-1.0=-0.064227715, val_rnn_1step_CC_maskV_-1.0=0.24731481, learning_rate=0.001\n", + "Epoch 14/129 - loss=rnn_1step_loss=0.71254188, rnn_1step_R2_maskV_-1.0=0.27550364, rnn_1step_CC_maskV_-1.0=0.5419209, rnn_1step_MSE_maskV_-1.0=0.712542, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.70459127, val_rnn_1step_R2_maskV_-1.0=0.17577413, val_rnn_1step_CC_maskV_-1.0=0.51164609, learning_rate=0.001\n", + "Epoch 27/129 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.55175871, rnn_1step_R2_maskV_-1.0=0.4366844, rnn_1step_CC_maskV_-1.0=0.6690886, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62741679, val_rnn_1step_R2_maskV_-1.0=0.26912251, val_rnn_1step_CC_maskV_-1.0=0.57786357, learning_rate=0.001\n", + "Epoch 40/129 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4700973, rnn_1step_R2_maskV_-1.0=0.52092963, rnn_1step_CC_maskV_-1.0=0.72713649, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58221763, val_rnn_1step_R2_maskV_-1.0=0.31934226, val_rnn_1step_CC_maskV_-1.0=0.62096518, learning_rate=0.001\n", + "Epoch 53/129 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42262745, rnn_1step_R2_maskV_-1.0=0.56989837, rnn_1step_CC_maskV_-1.0=0.75885516, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56646723, val_rnn_1step_R2_maskV_-1.0=0.33801976, val_rnn_1step_CC_maskV_-1.0=0.63592392, learning_rate=0.001\n", + "Epoch 66/129 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39930549, rnn_1step_R2_maskV_-1.0=0.59324801, rnn_1step_CC_maskV_-1.0=0.77424961, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55294502, val_rnn_1step_R2_maskV_-1.0=0.35410547, val_rnn_1step_CC_maskV_-1.0=0.63920695, learning_rate=0.001\n", + "Epoch 79/129 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.36583781, rnn_1step_R2_maskV_-1.0=0.62773347, rnn_1step_CC_maskV_-1.0=0.79637575, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56587631, val_rnn_1step_R2_maskV_-1.0=0.33980167, val_rnn_1step_CC_maskV_-1.0=0.65186143, learning_rate=0.001\n", + "Epoch 92/129 - loss=rnn_1step_loss=0.32862517, rnn_1step_R2_maskV_-1.0=0.66561234, rnn_1step_CC_maskV_-1.0=0.81843692, rnn_1step_MSE_maskV_-1.0=0.32862514, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53149962, val_rnn_1step_R2_maskV_-1.0=0.38162294, val_rnn_1step_CC_maskV_-1.0=0.66494906, learning_rate=0.001\n", + "Epoch 105/129 - loss=rnn_1step_loss=0.32039425, rnn_1step_R2_maskV_-1.0=0.67346936, rnn_1step_CC_maskV_-1.0=0.82535112, rnn_1step_MSE_maskV_-1.0=0.32039422, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53558755, val_rnn_1step_R2_maskV_-1.0=0.37448955, val_rnn_1step_CC_maskV_-1.0=0.66005665, learning_rate=0.001\n", + "Epoch 118/129 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29085922, rnn_1step_R2_maskV_-1.0=0.70417541, rnn_1step_CC_maskV_-1.0=0.84185445, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52788198, val_rnn_1step_R2_maskV_-1.0=0.38336158, val_rnn_1step_CC_maskV_-1.0=0.6703434, learning_rate=0.001\n", + "Epoch 129/129 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27439514, rnn_1step_R2_maskV_-1.0=0.72091901, rnn_1step_CC_maskV_-1.0=0.85092014, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53419316, val_rnn_1step_R2_maskV_-1.0=0.3772659, val_rnn_1step_CC_maskV_-1.0=0.66725981, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:36:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.83s\n", + "\u001b[32m2025-05-30 11:36:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:36:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 99 (stopped at 114 epochs).\n", + "\u001b[32m2025-05-30 11:36:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0015613, rnn_1_1step_R2_maskV_-1.0=-0.014235385, rnn_1_1step_CC_maskV_-1.0=0.021284834, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92303634, val_rnn_1_1step_R2_maskV_-1.0=-0.064492255, val_rnn_1_1step_CC_maskV_-1.0=0.27722037, learning_rate=0.001\n", + "Epoch 13/115 - loss=rnn_1_1step_loss=0.83242255, rnn_1_1step_R2_maskV_-1.0=0.15551123, rnn_1_1step_CC_maskV_-1.0=0.4187265, rnn_1_1step_MSE_maskV_-1.0=0.83242261, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.7725327, val_rnn_1_1step_R2_maskV_-1.0=0.10292074, val_rnn_1_1step_CC_maskV_-1.0=0.41625217, learning_rate=0.001\n", + "Epoch 25/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.60109717, rnn_1_1step_R2_maskV_-1.0=0.38600799, rnn_1_1step_CC_maskV_-1.0=0.63290352, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63994151, val_rnn_1_1step_R2_maskV_-1.0=0.25529295, val_rnn_1_1step_CC_maskV_-1.0=0.56782436, learning_rate=0.001\n", + "Epoch 37/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.52050793, rnn_1_1step_R2_maskV_-1.0=0.46704036, rnn_1_1step_CC_maskV_-1.0=0.69380319, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61150962, val_rnn_1_1step_R2_maskV_-1.0=0.29030171, val_rnn_1_1step_CC_maskV_-1.0=0.59295124, learning_rate=0.001\n", + "Epoch 49/115 - loss=rnn_1_1step_loss=0.41990075, rnn_1_1step_R2_maskV_-1.0=0.57081133, rnn_1_1step_CC_maskV_-1.0=0.76264781, rnn_1_1step_MSE_maskV_-1.0=0.41990072, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54630172, val_rnn_1_1step_R2_maskV_-1.0=0.36703122, val_rnn_1_1step_CC_maskV_-1.0=0.65148115, learning_rate=0.001\n", + "Epoch 61/115 - loss=rnn_1_1step_loss=0.35053775, rnn_1_1step_R2_maskV_-1.0=0.64176565, rnn_1_1step_CC_maskV_-1.0=0.80597663, rnn_1_1step_MSE_maskV_-1.0=0.35053772, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49752903, val_rnn_1_1step_R2_maskV_-1.0=0.4228209, val_rnn_1_1step_CC_maskV_-1.0=0.68966609, learning_rate=0.001\n", + "Epoch 73/115 - loss=rnn_1_1step_loss=0.30832729, rnn_1_1step_R2_maskV_-1.0=0.68540645, rnn_1_1step_CC_maskV_-1.0=0.83118749, rnn_1_1step_MSE_maskV_-1.0=0.30832726, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4744226, val_rnn_1_1step_R2_maskV_-1.0=0.44930992, val_rnn_1_1step_CC_maskV_-1.0=0.70740515, learning_rate=0.001\n", + "Epoch 85/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.27402553, rnn_1_1step_R2_maskV_-1.0=0.72087634, rnn_1_1step_CC_maskV_-1.0=0.85143071, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46443531, val_rnn_1_1step_R2_maskV_-1.0=0.46109366, val_rnn_1_1step_CC_maskV_-1.0=0.71508092, learning_rate=0.001\n", + "Epoch 97/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.25482109, rnn_1_1step_R2_maskV_-1.0=0.74067283, rnn_1_1step_CC_maskV_-1.0=0.8629868, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4787004, val_rnn_1_1step_R2_maskV_-1.0=0.44248831, val_rnn_1_1step_CC_maskV_-1.0=0.7129519, learning_rate=0.001\n", + "Epoch 109/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.23885296, rnn_1_1step_R2_maskV_-1.0=0.75689852, rnn_1_1step_CC_maskV_-1.0=0.87318623, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.44683707, val_rnn_1_1step_R2_maskV_-1.0=0.47872564, val_rnn_1_1step_CC_maskV_-1.0=0.73041874, learning_rate=0.001\n", + "Epoch 115/115 - loss=rnn_1_1step_loss=0.23376708, rnn_1_1step_R2_maskV_-1.0=0.76199114, rnn_1_1step_CC_maskV_-1.0=0.87521803, rnn_1_1step_MSE_maskV_-1.0=0.23376706, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46941233, val_rnn_1_1step_R2_maskV_-1.0=0.45217723, val_rnn_1_1step_CC_maskV_-1.0=0.71961254, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:36:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.35s\n", + "\u001b[32m2025-05-30 11:36:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.44046926)\n", + "\u001b[32m2025-05-30 11:36:22\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.227, R2_maskV_-1.0=0.772, CC_maskV_-1.0=0.88\n", + "\u001b[32m2025-05-30 11:36:22\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.415, R2_maskV_-1.0=0.529, CC_maskV_-1.0=0.751\n", + "\u001b[32m2025-05-30 11:36:22\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:36:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:37:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 233 (stopped at 248 epochs).\n", + "\u001b[32m2025-05-30 11:37:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/249 - loss=1.9859103, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.047952831, MSE_maskV_-1.0=1.9834224, val_loss=1.1509759, val_CC_maskV_-1.0=0.083670698, val_MSE_maskV_-1.0=1.1450876, learning_rate=0.001\n", + "Epoch 26/249 - loss=0.89050812, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.33634514, MSE_maskV_-1.0=0.89071071, val_loss=0.9249838, val_CC_maskV_-1.0=0.33388597, val_MSE_maskV_-1.0=0.92189902, learning_rate=0.001\n", + "Epoch 51/249 - loss=0.86772162, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36699528, MSE_maskV_-1.0=0.86717713, val_loss=0.9038344, val_CC_maskV_-1.0=0.36159086, val_MSE_maskV_-1.0=0.90084928, learning_rate=0.001\n", + "Epoch 76/249 - loss=0.85636312, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38282058, MSE_maskV_-1.0=0.85608482, val_loss=0.8937487, val_CC_maskV_-1.0=0.3736183, val_MSE_maskV_-1.0=0.89141601, learning_rate=0.001\n", + "Epoch 101/249 - loss=0.84853381, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39262554, MSE_maskV_-1.0=0.8477087, val_loss=0.88661724, val_CC_maskV_-1.0=0.38361245, val_MSE_maskV_-1.0=0.88333249, learning_rate=0.001\n", + "Epoch 126/249 - loss=0.84273416, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39959207, MSE_maskV_-1.0=0.84255898, val_loss=0.87983972, val_CC_maskV_-1.0=0.39237884, val_MSE_maskV_-1.0=0.87663621, learning_rate=0.001\n", + "Epoch 151/249 - loss=0.83865249, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40432975, MSE_maskV_-1.0=0.83856726, val_loss=0.87795442, val_CC_maskV_-1.0=0.39495865, val_MSE_maskV_-1.0=0.87476766, learning_rate=0.001\n", + "Epoch 176/249 - loss=0.83486253, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40855229, MSE_maskV_-1.0=0.83411634, val_loss=0.87389022, val_CC_maskV_-1.0=0.39940688, val_MSE_maskV_-1.0=0.87060279, learning_rate=0.001\n", + "Epoch 201/249 - loss=0.83171403, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41304365, MSE_maskV_-1.0=0.83135629, val_loss=0.87300295, val_CC_maskV_-1.0=0.39864379, val_MSE_maskV_-1.0=0.87009054, learning_rate=0.001\n", + "Epoch 226/249 - loss=0.82934934, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41511023, MSE_maskV_-1.0=0.82903689, val_loss=0.86957699, val_CC_maskV_-1.0=0.40475282, val_MSE_maskV_-1.0=0.86614347, learning_rate=0.001\n", + "Epoch 249/249 - loss=0.8270306, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41777828, MSE_maskV_-1.0=0.82663161, val_loss=0.86798137, val_CC_maskV_-1.0=0.40593612, val_MSE_maskV_-1.0=0.86454147, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:37:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 60.41s\n", + "\u001b[32m2025-05-30 11:37:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:38:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 233 (stopped at 248 epochs).\n", + "\u001b[32m2025-05-30 11:38:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/249 - loss=1.8065945, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0034733049, MSE_maskV_-1.0=1.8044096, val_loss=1.1071064, val_CC_maskV_-1.0=0.070653319, val_MSE_maskV_-1.0=1.1024944, learning_rate=0.001\n", + "Epoch 26/249 - loss=0.8931309, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.33246651, MSE_maskV_-1.0=0.89333904, val_loss=0.93007398, val_CC_maskV_-1.0=0.32530648, val_MSE_maskV_-1.0=0.92685425, learning_rate=0.001\n", + "Epoch 51/249 - loss=0.86877525, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36561599, MSE_maskV_-1.0=0.8682273, val_loss=0.90651476, val_CC_maskV_-1.0=0.35753956, val_MSE_maskV_-1.0=0.90343827, learning_rate=0.001\n", + "Epoch 76/249 - loss=0.85697436, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38200244, MSE_maskV_-1.0=0.85669881, val_loss=0.89594483, val_CC_maskV_-1.0=0.37047213, val_MSE_maskV_-1.0=0.8935585, learning_rate=0.001\n", + "Epoch 101/249 - loss=0.84894872, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39213336, MSE_maskV_-1.0=0.8481046, val_loss=0.8881411, val_CC_maskV_-1.0=0.38156983, val_MSE_maskV_-1.0=0.88477236, learning_rate=0.001\n", + "Epoch 126/249 - loss=0.84299624, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39929605, MSE_maskV_-1.0=0.84282261, val_loss=0.88115895, val_CC_maskV_-1.0=0.39072219, val_MSE_maskV_-1.0=0.87783873, learning_rate=0.001\n", + "Epoch 151/249 - loss=0.83879203, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40419772, MSE_maskV_-1.0=0.8387115, val_loss=0.87902361, val_CC_maskV_-1.0=0.39370194, val_MSE_maskV_-1.0=0.8757084, learning_rate=0.001\n", + "Epoch 176/249 - loss=0.83490539, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40852118, MSE_maskV_-1.0=0.83416086, val_loss=0.87488776, val_CC_maskV_-1.0=0.39823782, val_MSE_maskV_-1.0=0.87147719, learning_rate=0.001\n", + "Epoch 201/249 - loss=0.83168995, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41312861, MSE_maskV_-1.0=0.83132297, val_loss=0.87375659, val_CC_maskV_-1.0=0.39780793, val_MSE_maskV_-1.0=0.87071753, learning_rate=0.001\n", + "Epoch 226/249 - loss=0.8292889, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41520718, MSE_maskV_-1.0=0.828978, val_loss=0.87020028, val_CC_maskV_-1.0=0.40407243, val_MSE_maskV_-1.0=0.86665863, learning_rate=0.001\n", + "Epoch 249/249 - loss=0.8269248, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41793865, MSE_maskV_-1.0=0.82652277, val_loss=0.86853778, val_CC_maskV_-1.0=0.40532079, val_MSE_maskV_-1.0=0.86498606, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:38:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 60.43s\n", + "\u001b[32m2025-05-30 11:38:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.86660123)\n", + "\u001b[32m2025-05-30 11:38:23\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 779us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:38:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.827, R2_maskV_-1.0=0.173, CC_maskV_-1.0=0.418\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 767us/step\n", + "51/51 [==============================] - 0s 829us/step\n", + "84/84 [==============================] - 0s 703us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:38:24\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_uAKCz1HL64U_ErSV16\" (12/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_uAKCz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:38:24\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_uAKCy1HL64U_ErSV16\" (13/16)\n", + "\u001b[32m2025-05-30 11:38:24\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:38:24\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:38:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:38:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:38:24\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:38:24\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:38:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:38:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 88 (stopped at 103 epochs).\n", + "\u001b[32m2025-05-30 11:38:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/104 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.000617, rnn_1step_R2_maskV_-1.0=-0.013253734, rnn_1step_CC_maskV_-1.0=0.1237113, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92138821, val_rnn_1step_R2_maskV_-1.0=-0.062491551, val_rnn_1step_CC_maskV_-1.0=0.25277314, learning_rate=0.001\n", + "Epoch 12/104 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.78440696, rnn_1step_R2_maskV_-1.0=0.2035158, rnn_1step_CC_maskV_-1.0=0.46750295, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.74022835, val_rnn_1step_R2_maskV_-1.0=0.13595691, val_rnn_1step_CC_maskV_-1.0=0.44705194, learning_rate=0.001\n", + "Epoch 23/104 - loss=rnn_1step_loss=0.56702423, rnn_1step_R2_maskV_-1.0=0.42070955, rnn_1step_CC_maskV_-1.0=0.65846622, rnn_1step_MSE_maskV_-1.0=0.56702429, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61968189, val_rnn_1step_R2_maskV_-1.0=0.27986008, val_rnn_1step_CC_maskV_-1.0=0.58166558, learning_rate=0.001\n", + "Epoch 34/104 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.47482443, rnn_1step_R2_maskV_-1.0=0.51511484, rnn_1step_CC_maskV_-1.0=0.7245121, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5691449, val_rnn_1step_R2_maskV_-1.0=0.33482516, val_rnn_1step_CC_maskV_-1.0=0.62935978, learning_rate=0.001\n", + "Epoch 45/104 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39790487, rnn_1step_R2_maskV_-1.0=0.59461743, rnn_1step_CC_maskV_-1.0=0.77577466, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51986319, val_rnn_1step_R2_maskV_-1.0=0.39114392, val_rnn_1step_CC_maskV_-1.0=0.66712892, learning_rate=0.001\n", + "Epoch 56/104 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.36005914, rnn_1step_R2_maskV_-1.0=0.63353056, rnn_1step_CC_maskV_-1.0=0.80300403, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50859612, val_rnn_1step_R2_maskV_-1.0=0.40406328, val_rnn_1step_CC_maskV_-1.0=0.68515527, learning_rate=0.001\n", + "Epoch 67/104 - loss=rnn_1step_loss=0.32564846, rnn_1step_R2_maskV_-1.0=0.66888642, rnn_1step_CC_maskV_-1.0=0.82102662, rnn_1step_MSE_maskV_-1.0=0.32564843, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.503169, val_rnn_1step_R2_maskV_-1.0=0.41097939, val_rnn_1step_CC_maskV_-1.0=0.68863326, learning_rate=0.001\n", + "Epoch 78/104 - loss=rnn_1step_loss=0.3088409, rnn_1step_R2_maskV_-1.0=0.68594885, rnn_1step_CC_maskV_-1.0=0.8312822, rnn_1step_MSE_maskV_-1.0=0.30884093, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50184304, val_rnn_1step_R2_maskV_-1.0=0.41369829, val_rnn_1step_CC_maskV_-1.0=0.69180059, learning_rate=0.001\n", + "Epoch 89/104 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29136768, rnn_1step_R2_maskV_-1.0=0.70371842, rnn_1step_CC_maskV_-1.0=0.84131241, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5118776, val_rnn_1step_R2_maskV_-1.0=0.40227717, val_rnn_1step_CC_maskV_-1.0=0.68985879, learning_rate=0.001\n", + "Epoch 100/104 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27533296, rnn_1step_R2_maskV_-1.0=0.72031456, rnn_1step_CC_maskV_-1.0=0.85088134, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49972591, val_rnn_1step_R2_maskV_-1.0=0.4172658, val_rnn_1step_CC_maskV_-1.0=0.69741714, learning_rate=0.001\n", + "Epoch 104/104 - loss=rnn_1step_loss=0.26993784, rnn_1step_R2_maskV_-1.0=0.72570872, rnn_1step_CC_maskV_-1.0=0.85425186, rnn_1step_MSE_maskV_-1.0=0.26993787, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5016067, val_rnn_1step_R2_maskV_-1.0=0.41547379, val_rnn_1step_CC_maskV_-1.0=0.69807649, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:38:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 13.04s\n", + "\u001b[32m2025-05-30 11:38:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:38:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 118 (stopped at 133 epochs).\n", + "\u001b[32m2025-05-30 11:38:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/134 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.000711, rnn_1_1step_R2_maskV_-1.0=-0.013360117, rnn_1_1step_CC_maskV_-1.0=0.11691718, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92173713, val_rnn_1_1step_R2_maskV_-1.0=-0.062876761, val_rnn_1_1step_CC_maskV_-1.0=0.26710343, learning_rate=0.001\n", + "Epoch 15/134 - loss=rnn_1_1step_loss=0.74483615, rnn_1_1step_R2_maskV_-1.0=0.24205133, rnn_1_1step_CC_maskV_-1.0=0.51405096, rnn_1_1step_MSE_maskV_-1.0=0.74483621, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.71613294, val_rnn_1_1step_R2_maskV_-1.0=0.17478992, val_rnn_1_1step_CC_maskV_-1.0=0.47945225, learning_rate=0.001\n", + "Epoch 29/134 - loss=rnn_1_1step_loss=0.48306271, rnn_1_1step_R2_maskV_-1.0=0.50791812, rnn_1_1step_CC_maskV_-1.0=0.71903735, rnn_1_1step_MSE_maskV_-1.0=0.48306268, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56548285, val_rnn_1_1step_R2_maskV_-1.0=0.34068859, val_rnn_1_1step_CC_maskV_-1.0=0.63394547, learning_rate=0.001\n", + "Epoch 43/134 - loss=rnn_1_1step_loss=0.36735454, rnn_1_1step_R2_maskV_-1.0=0.62621742, rnn_1_1step_CC_maskV_-1.0=0.7960273, rnn_1_1step_MSE_maskV_-1.0=0.36735457, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53550655, val_rnn_1_1step_R2_maskV_-1.0=0.37341112, val_rnn_1_1step_CC_maskV_-1.0=0.66886258, learning_rate=0.001\n", + "Epoch 57/134 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31180504, rnn_1_1step_R2_maskV_-1.0=0.68334615, rnn_1_1step_CC_maskV_-1.0=0.82949692, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51653886, val_rnn_1_1step_R2_maskV_-1.0=0.39760414, val_rnn_1_1step_CC_maskV_-1.0=0.68844837, learning_rate=0.001\n", + "Epoch 71/134 - loss=rnn_1_1step_loss=0.27387416, rnn_1_1step_R2_maskV_-1.0=0.72234732, rnn_1_1step_CC_maskV_-1.0=0.85225129, rnn_1_1step_MSE_maskV_-1.0=0.27387413, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48539472, val_rnn_1_1step_R2_maskV_-1.0=0.43533751, val_rnn_1_1step_CC_maskV_-1.0=0.70860475, learning_rate=0.001\n", + "Epoch 85/134 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.2466176, rnn_1_1step_R2_maskV_-1.0=0.75006825, rnn_1_1step_CC_maskV_-1.0=0.86811835, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47999573, val_rnn_1_1step_R2_maskV_-1.0=0.44219154, val_rnn_1_1step_CC_maskV_-1.0=0.71390206, learning_rate=0.001\n", + "Epoch 99/134 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.22948426, rnn_1_1step_R2_maskV_-1.0=0.7675342, rnn_1_1step_CC_maskV_-1.0=0.8779428, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47686782, val_rnn_1_1step_R2_maskV_-1.0=0.4467243, val_rnn_1_1step_CC_maskV_-1.0=0.7178992, learning_rate=0.001\n", + "Epoch 113/134 - loss=rnn_1_1step_loss=0.21900725, rnn_1_1step_R2_maskV_-1.0=0.77839226, rnn_1_1step_CC_maskV_-1.0=0.88359457, rnn_1_1step_MSE_maskV_-1.0=0.21900724, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47545227, val_rnn_1_1step_R2_maskV_-1.0=0.44725218, val_rnn_1_1step_CC_maskV_-1.0=0.71544766, learning_rate=0.001\n", + "Epoch 127/134 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.20919174, rnn_1_1step_R2_maskV_-1.0=0.78830469, rnn_1_1step_CC_maskV_-1.0=0.88929892, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46681681, val_rnn_1_1step_R2_maskV_-1.0=0.4568719, val_rnn_1_1step_CC_maskV_-1.0=0.71963412, learning_rate=0.001\n", + "Epoch 134/134 - loss=rnn_1_1step_loss=0.20253907, rnn_1_1step_R2_maskV_-1.0=0.79475427, rnn_1_1step_CC_maskV_-1.0=0.89350337, rnn_1_1step_MSE_maskV_-1.0=0.20253906, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47970822, val_rnn_1_1step_R2_maskV_-1.0=0.44306958, val_rnn_1_1step_CC_maskV_-1.0=0.71593195, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:38:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 16.25s\n", + "\u001b[32m2025-05-30 11:38:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.46476308)\n", + "\u001b[32m2025-05-30 11:38:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.201, R2_maskV_-1.0=0.799, CC_maskV_-1.0=0.894\n", + "\u001b[32m2025-05-30 11:38:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.435, R2_maskV_-1.0=0.506, CC_maskV_-1.0=0.743\n", + "\u001b[32m2025-05-30 11:38:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:38:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:39:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 101 (stopped at 116 epochs).\n", + "\u001b[32m2025-05-30 11:39:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/117 - loss=1.0241015, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.16918279, MSE_maskV_-1.0=1.0240849, val_loss=0.97686964, val_CC_maskV_-1.0=0.24041004, val_MSE_maskV_-1.0=0.97413468, learning_rate=0.001\n", + "Epoch 13/117 - loss=0.830957, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41278741, MSE_maskV_-1.0=0.83014405, val_loss=0.88643062, val_CC_maskV_-1.0=0.38574162, val_MSE_maskV_-1.0=0.88330984, learning_rate=0.001\n", + "Epoch 25/117 - loss=0.79889673, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45012012, MSE_maskV_-1.0=0.79897428, val_loss=0.85757661, val_CC_maskV_-1.0=0.41970631, val_MSE_maskV_-1.0=0.85465086, learning_rate=0.001\n", + "Epoch 37/117 - loss=0.7797755, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47007239, MSE_maskV_-1.0=0.78007704, val_loss=0.84225225, val_CC_maskV_-1.0=0.437033, val_MSE_maskV_-1.0=0.8389625, learning_rate=0.001\n", + "Epoch 49/117 - loss=0.76742327, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48221117, MSE_maskV_-1.0=0.76732212, val_loss=0.83444339, val_CC_maskV_-1.0=0.44402558, val_MSE_maskV_-1.0=0.83193827, learning_rate=0.001\n", + "Epoch 61/117 - loss=0.75853741, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49171868, MSE_maskV_-1.0=0.75872159, val_loss=0.82381433, val_CC_maskV_-1.0=0.45382515, val_MSE_maskV_-1.0=0.82119936, learning_rate=0.001\n", + "Epoch 73/117 - loss=0.75123489, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49739283, MSE_maskV_-1.0=0.75142211, val_loss=0.8200317, val_CC_maskV_-1.0=0.45716596, val_MSE_maskV_-1.0=0.81744641, learning_rate=0.001\n", + "Epoch 85/117 - loss=0.74605393, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50328159, MSE_maskV_-1.0=0.74590379, val_loss=0.81430525, val_CC_maskV_-1.0=0.46229064, val_MSE_maskV_-1.0=0.81206417, learning_rate=0.001\n", + "Epoch 97/117 - loss=0.74129868, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50804049, MSE_maskV_-1.0=0.74067098, val_loss=0.81150699, val_CC_maskV_-1.0=0.46439934, val_MSE_maskV_-1.0=0.80930388, learning_rate=0.001\n", + "Epoch 109/117 - loss=0.73740923, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51142395, MSE_maskV_-1.0=0.73707438, val_loss=0.80868506, val_CC_maskV_-1.0=0.46808863, val_MSE_maskV_-1.0=0.80656415, learning_rate=0.001\n", + "Epoch 117/117 - loss=0.73459727, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51432085, MSE_maskV_-1.0=0.73445326, val_loss=0.81002933, val_CC_maskV_-1.0=0.46513405, val_MSE_maskV_-1.0=0.80812699, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:39:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 30.99s\n", + "\u001b[32m2025-05-30 11:39:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:40:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 172 (stopped at 187 epochs).\n", + "\u001b[32m2025-05-30 11:40:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/188 - loss=1.0304121, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.16221757, MSE_maskV_-1.0=1.0304334, val_loss=0.97837549, val_CC_maskV_-1.0=0.23730375, val_MSE_maskV_-1.0=0.97564524, learning_rate=0.001\n", + "Epoch 20/188 - loss=0.81010473, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43827367, MSE_maskV_-1.0=0.80993623, val_loss=0.86793852, val_CC_maskV_-1.0=0.40668002, val_MSE_maskV_-1.0=0.86589932, learning_rate=0.001\n", + "Epoch 39/188 - loss=0.77908939, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47041857, MSE_maskV_-1.0=0.77859497, val_loss=0.84417379, val_CC_maskV_-1.0=0.43308127, val_MSE_maskV_-1.0=0.84150225, learning_rate=0.001\n", + "Epoch 58/188 - loss=0.76304096, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48657203, MSE_maskV_-1.0=0.76244813, val_loss=0.83526129, val_CC_maskV_-1.0=0.4410772, val_MSE_maskV_-1.0=0.83297735, learning_rate=0.001\n", + "Epoch 77/188 - loss=0.75324982, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49643195, MSE_maskV_-1.0=0.75260347, val_loss=0.82336873, val_CC_maskV_-1.0=0.45475891, val_MSE_maskV_-1.0=0.82114136, learning_rate=0.001\n", + "Epoch 96/188 - loss=0.7454102, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5026533, MSE_maskV_-1.0=0.74480999, val_loss=0.81930298, val_CC_maskV_-1.0=0.4562169, val_MSE_maskV_-1.0=0.81802595, learning_rate=0.001\n", + "Epoch 115/188 - loss=0.73983598, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50968599, MSE_maskV_-1.0=0.74018943, val_loss=0.81643844, val_CC_maskV_-1.0=0.46148187, val_MSE_maskV_-1.0=0.81520748, learning_rate=0.001\n", + "Epoch 134/188 - loss=0.73592371, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51318955, MSE_maskV_-1.0=0.73606759, val_loss=0.81137973, val_CC_maskV_-1.0=0.46638551, val_MSE_maskV_-1.0=0.80917358, learning_rate=0.001\n", + "Epoch 153/188 - loss=0.73221588, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51660776, MSE_maskV_-1.0=0.73170251, val_loss=0.80561632, val_CC_maskV_-1.0=0.4724929, val_MSE_maskV_-1.0=0.80415559, learning_rate=0.001\n", + "Epoch 172/188 - loss=0.72917038, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52011597, MSE_maskV_-1.0=0.72970688, val_loss=0.8016398, val_CC_maskV_-1.0=0.47529367, val_MSE_maskV_-1.0=0.79964304, learning_rate=0.001\n", + "Epoch 188/188 - loss=0.72707897, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52102405, MSE_maskV_-1.0=0.72643244, val_loss=0.80309254, val_CC_maskV_-1.0=0.47350287, val_MSE_maskV_-1.0=0.8014307, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:40:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 51.00s\n", + "\u001b[32m2025-05-30 11:40:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.8016398)\n", + "\u001b[32m2025-05-30 11:40:17\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 818us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:40:18\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.725, R2_maskV_-1.0=0.276, CC_maskV_-1.0=0.525\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 799us/step\n", + "51/51 [==============================] - 0s 996us/step\n", + "84/84 [==============================] - 0s 797us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:40:18\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_uAKCy1HL64U_ErSV16\" (13/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_uAKCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:40:19\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_ACzCy1HL64U_ErSV16\" (14/16)\n", + "\u001b[32m2025-05-30 11:40:19\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:40:19\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:40:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:40:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:40:19\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:40:19\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:40:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:40:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 107 (stopped at 122 epochs).\n", + "\u001b[32m2025-05-30 11:40:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/123 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0014006, rnn_1step_R2_maskV_-1.0=-0.014040712, rnn_1step_CC_maskV_-1.0=0.029654989, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92142791, val_rnn_1step_R2_maskV_-1.0=-0.062672719, val_rnn_1step_CC_maskV_-1.0=0.25057805, learning_rate=0.001\n", + "Epoch 14/123 - loss=rnn_1step_loss=0.77278346, rnn_1step_R2_maskV_-1.0=0.21577519, rnn_1step_CC_maskV_-1.0=0.48681143, rnn_1step_MSE_maskV_-1.0=0.77278352, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.73681384, val_rnn_1step_R2_maskV_-1.0=0.14959337, val_rnn_1step_CC_maskV_-1.0=0.45816991, learning_rate=0.001\n", + "Epoch 27/123 - loss=rnn_1step_loss=0.54404706, rnn_1step_R2_maskV_-1.0=0.44655049, rnn_1step_CC_maskV_-1.0=0.67610085, rnn_1step_MSE_maskV_-1.0=0.544047, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57320511, val_rnn_1step_R2_maskV_-1.0=0.3321498, val_rnn_1step_CC_maskV_-1.0=0.62167227, learning_rate=0.001\n", + "Epoch 40/123 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.44858813, rnn_1step_R2_maskV_-1.0=0.54372054, rnn_1step_CC_maskV_-1.0=0.74336565, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52955633, val_rnn_1step_R2_maskV_-1.0=0.37975866, val_rnn_1step_CC_maskV_-1.0=0.66761184, learning_rate=0.001\n", + "Epoch 53/123 - loss=rnn_1step_loss=0.41512427, rnn_1step_R2_maskV_-1.0=0.57774007, rnn_1step_CC_maskV_-1.0=0.76560146, rnn_1step_MSE_maskV_-1.0=0.41512424, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51679969, val_rnn_1step_R2_maskV_-1.0=0.39400321, val_rnn_1step_CC_maskV_-1.0=0.67744887, learning_rate=0.001\n", + "Epoch 66/123 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39055932, rnn_1step_R2_maskV_-1.0=0.6027413, rnn_1step_CC_maskV_-1.0=0.77992326, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5208959, val_rnn_1step_R2_maskV_-1.0=0.38868469, val_rnn_1step_CC_maskV_-1.0=0.67903459, learning_rate=0.001\n", + "Epoch 79/123 - loss=rnn_1step_loss=0.38072667, rnn_1step_R2_maskV_-1.0=0.61267042, rnn_1step_CC_maskV_-1.0=0.78756464, rnn_1step_MSE_maskV_-1.0=0.38072664, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4894546, val_rnn_1step_R2_maskV_-1.0=0.42531946, val_rnn_1step_CC_maskV_-1.0=0.69706893, learning_rate=0.001\n", + "Epoch 92/123 - loss=rnn_1step_loss=0.35991588, rnn_1step_R2_maskV_-1.0=0.63390136, rnn_1step_CC_maskV_-1.0=0.80024272, rnn_1step_MSE_maskV_-1.0=0.35991585, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49147391, val_rnn_1step_R2_maskV_-1.0=0.42336804, val_rnn_1step_CC_maskV_-1.0=0.69950432, learning_rate=0.001\n", + "Epoch 105/123 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3486588, rnn_1step_R2_maskV_-1.0=0.64545041, rnn_1step_CC_maskV_-1.0=0.80824971, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47736201, val_rnn_1step_R2_maskV_-1.0=0.44135731, val_rnn_1step_CC_maskV_-1.0=0.70506251, learning_rate=0.001\n", + "Epoch 118/123 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33793345, rnn_1step_R2_maskV_-1.0=0.65628505, rnn_1step_CC_maskV_-1.0=0.81460786, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46543321, val_rnn_1step_R2_maskV_-1.0=0.45420715, val_rnn_1step_CC_maskV_-1.0=0.71677929, learning_rate=0.001\n", + "Epoch 123/123 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34691444, rnn_1step_R2_maskV_-1.0=0.64682585, rnn_1step_CC_maskV_-1.0=0.80873239, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4785533, val_rnn_1step_R2_maskV_-1.0=0.43704331, val_rnn_1step_CC_maskV_-1.0=0.71406239, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:40:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.39s\n", + "\u001b[32m2025-05-30 11:40:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:40:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 197 (stopped at 212 epochs).\n", + "\u001b[32m2025-05-30 11:40:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/213 - loss=rnn_1_1step_loss=1.0010535, rnn_1_1step_R2_maskV_-1.0=-0.013712928, rnn_1_1step_CC_maskV_-1.0=0.092870191, rnn_1_1step_MSE_maskV_-1.0=1.0010533, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92174911, val_rnn_1_1step_R2_maskV_-1.0=-0.06294696, val_rnn_1_1step_CC_maskV_-1.0=0.31594667, learning_rate=0.001\n", + "Epoch 23/213 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.59401351, rnn_1_1step_R2_maskV_-1.0=0.39418903, rnn_1_1step_CC_maskV_-1.0=0.6388768, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6287623, val_rnn_1_1step_R2_maskV_-1.0=0.27078804, val_rnn_1_1step_CC_maskV_-1.0=0.57230437, learning_rate=0.001\n", + "Epoch 45/213 - loss=rnn_1_1step_loss=0.47028092, rnn_1_1step_R2_maskV_-1.0=0.52021277, rnn_1_1step_CC_maskV_-1.0=0.72832561, rnn_1_1step_MSE_maskV_-1.0=0.47028095, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57147348, val_rnn_1_1step_R2_maskV_-1.0=0.33558458, val_rnn_1_1step_CC_maskV_-1.0=0.63169491, learning_rate=0.001\n", + "Epoch 67/213 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39544344, rnn_1_1step_R2_maskV_-1.0=0.59746462, rnn_1_1step_CC_maskV_-1.0=0.77776814, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52028573, val_rnn_1_1step_R2_maskV_-1.0=0.39020652, val_rnn_1_1step_CC_maskV_-1.0=0.67469782, learning_rate=0.001\n", + "Epoch 89/213 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.3714734, rnn_1_1step_R2_maskV_-1.0=0.62217683, rnn_1_1step_CC_maskV_-1.0=0.79405981, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51497298, val_rnn_1_1step_R2_maskV_-1.0=0.39470375, val_rnn_1_1step_CC_maskV_-1.0=0.68121356, learning_rate=0.001\n", + "Epoch 111/213 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.34975699, rnn_1_1step_R2_maskV_-1.0=0.6442306, rnn_1_1step_CC_maskV_-1.0=0.80621409, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49910975, val_rnn_1_1step_R2_maskV_-1.0=0.41420427, val_rnn_1_1step_CC_maskV_-1.0=0.69509226, learning_rate=0.001\n", + "Epoch 133/213 - loss=rnn_1_1step_loss=0.33904639, rnn_1_1step_R2_maskV_-1.0=0.65530592, rnn_1_1step_CC_maskV_-1.0=0.81328839, rnn_1_1step_MSE_maskV_-1.0=0.33904642, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48522606, val_rnn_1_1step_R2_maskV_-1.0=0.43108651, val_rnn_1_1step_CC_maskV_-1.0=0.70201445, learning_rate=0.001\n", + "Epoch 155/213 - loss=rnn_1_1step_loss=0.32926324, rnn_1_1step_R2_maskV_-1.0=0.66520691, rnn_1_1step_CC_maskV_-1.0=0.82116902, rnn_1_1step_MSE_maskV_-1.0=0.32926321, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48502144, val_rnn_1_1step_R2_maskV_-1.0=0.43195656, val_rnn_1_1step_CC_maskV_-1.0=0.70552707, learning_rate=0.001\n", + "Epoch 177/213 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32007262, rnn_1_1step_R2_maskV_-1.0=0.67402148, rnn_1_1step_CC_maskV_-1.0=0.82615066, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46928748, val_rnn_1_1step_R2_maskV_-1.0=0.4528397, val_rnn_1_1step_CC_maskV_-1.0=0.71286404, learning_rate=0.001\n", + "Epoch 199/213 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31009984, rnn_1_1step_R2_maskV_-1.0=0.68470037, rnn_1_1step_CC_maskV_-1.0=0.83188587, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46708989, val_rnn_1_1step_R2_maskV_-1.0=0.45575166, val_rnn_1_1step_CC_maskV_-1.0=0.71425205, learning_rate=0.001\n", + "Epoch 213/213 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30058554, rnn_1_1step_R2_maskV_-1.0=0.69404328, rnn_1_1step_CC_maskV_-1.0=0.83691102, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4660612, val_rnn_1_1step_R2_maskV_-1.0=0.45759663, val_rnn_1_1step_CC_maskV_-1.0=0.71839237, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:40:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 24.49s\n", + "\u001b[32m2025-05-30 11:40:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.44879735)\n", + "\u001b[32m2025-05-30 11:41:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.323, R2_maskV_-1.0=0.676, CC_maskV_-1.0=0.823\n", + "\u001b[32m2025-05-30 11:41:01\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.45, R2_maskV_-1.0=0.484, CC_maskV_-1.0=0.732\n", + "\u001b[32m2025-05-30 11:41:01\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:41:01\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:41:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 122 (stopped at 137 epochs).\n", + "\u001b[32m2025-05-30 11:41:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/138 - loss=1.2765275, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.17267819, MSE_maskV_-1.0=1.2755303, val_loss=0.95015037, val_CC_maskV_-1.0=0.29858777, val_MSE_maskV_-1.0=0.94701159, learning_rate=0.001\n", + "Epoch 15/138 - loss=0.69068676, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55551505, MSE_maskV_-1.0=0.69097149, val_loss=0.73531061, val_CC_maskV_-1.0=0.536892, val_MSE_maskV_-1.0=0.73203856, learning_rate=0.001\n", + "Epoch 29/138 - loss=0.6513046, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58871013, MSE_maskV_-1.0=0.65098518, val_loss=0.70445973, val_CC_maskV_-1.0=0.56520122, val_MSE_maskV_-1.0=0.70062363, learning_rate=0.001\n", + "Epoch 43/138 - loss=0.63591427, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6020484, MSE_maskV_-1.0=0.63573468, val_loss=0.69253743, val_CC_maskV_-1.0=0.57499993, val_MSE_maskV_-1.0=0.68945956, learning_rate=0.001\n", + "Epoch 57/138 - loss=0.62640375, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60980201, MSE_maskV_-1.0=0.62677383, val_loss=0.68885863, val_CC_maskV_-1.0=0.57988966, val_MSE_maskV_-1.0=0.68506646, learning_rate=0.001\n", + "Epoch 71/138 - loss=0.61967361, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61503708, MSE_maskV_-1.0=0.62130284, val_loss=0.68183345, val_CC_maskV_-1.0=0.58538073, val_MSE_maskV_-1.0=0.6789273, learning_rate=0.001\n", + "Epoch 85/138 - loss=0.61404294, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61962539, MSE_maskV_-1.0=0.61404163, val_loss=0.67513108, val_CC_maskV_-1.0=0.59059042, val_MSE_maskV_-1.0=0.67243516, learning_rate=0.001\n", + "Epoch 99/138 - loss=0.61005276, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62272435, MSE_maskV_-1.0=0.60950267, val_loss=0.67774487, val_CC_maskV_-1.0=0.58866626, val_MSE_maskV_-1.0=0.67514372, learning_rate=0.001\n", + "Epoch 113/138 - loss=0.60731679, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62432033, MSE_maskV_-1.0=0.61093134, val_loss=0.67470539, val_CC_maskV_-1.0=0.59106821, val_MSE_maskV_-1.0=0.67258662, learning_rate=0.001\n", + "Epoch 127/138 - loss=0.60367185, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62695032, MSE_maskV_-1.0=0.60468721, val_loss=0.67681056, val_CC_maskV_-1.0=0.58827329, val_MSE_maskV_-1.0=0.67497492, learning_rate=0.001\n", + "Epoch 138/138 - loss=0.60206854, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62896383, MSE_maskV_-1.0=0.60189515, val_loss=0.66928661, val_CC_maskV_-1.0=0.59491581, val_MSE_maskV_-1.0=0.66701484, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:41:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 36.03s\n", + "\u001b[32m2025-05-30 11:41:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:42:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 153 (stopped at 168 epochs).\n", + "\u001b[32m2025-05-30 11:42:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/169 - loss=1.4327213, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.13640186, MSE_maskV_-1.0=1.4311879, val_loss=0.96542317, val_CC_maskV_-1.0=0.27866802, val_MSE_maskV_-1.0=0.96131593, learning_rate=0.001\n", + "Epoch 18/169 - loss=0.68899727, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55735803, MSE_maskV_-1.0=0.68931115, val_loss=0.73952585, val_CC_maskV_-1.0=0.53277892, val_MSE_maskV_-1.0=0.73669958, learning_rate=0.001\n", + "Epoch 35/169 - loss=0.64809525, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59185815, MSE_maskV_-1.0=0.64771682, val_loss=0.7015726, val_CC_maskV_-1.0=0.56641847, val_MSE_maskV_-1.0=0.69862252, learning_rate=0.001\n", + "Epoch 52/169 - loss=0.63235855, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60518408, MSE_maskV_-1.0=0.63319546, val_loss=0.68826222, val_CC_maskV_-1.0=0.57903665, val_MSE_maskV_-1.0=0.68543798, learning_rate=0.001\n", + "Epoch 69/169 - loss=0.62443095, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61071283, MSE_maskV_-1.0=0.62414581, val_loss=0.67731994, val_CC_maskV_-1.0=0.58777291, val_MSE_maskV_-1.0=0.67450982, learning_rate=0.001\n", + "Epoch 86/169 - loss=0.61774361, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61676115, MSE_maskV_-1.0=0.61731726, val_loss=0.67954558, val_CC_maskV_-1.0=0.58596116, val_MSE_maskV_-1.0=0.67691684, learning_rate=0.001\n", + "Epoch 103/169 - loss=0.61389416, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61990219, MSE_maskV_-1.0=0.6138621, val_loss=0.67518973, val_CC_maskV_-1.0=0.5898006, val_MSE_maskV_-1.0=0.6716814, learning_rate=0.001\n", + "Epoch 120/169 - loss=0.61054242, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62214786, MSE_maskV_-1.0=0.61049682, val_loss=0.67228669, val_CC_maskV_-1.0=0.59219986, val_MSE_maskV_-1.0=0.6688987, learning_rate=0.001\n", + "Epoch 137/169 - loss=0.60763615, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6246165, MSE_maskV_-1.0=0.60727048, val_loss=0.67365688, val_CC_maskV_-1.0=0.59023285, val_MSE_maskV_-1.0=0.67095029, learning_rate=0.001\n", + "Epoch 154/169 - loss=0.60459316, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62662864, MSE_maskV_-1.0=0.60467136, val_loss=0.67203361, val_CC_maskV_-1.0=0.59178156, val_MSE_maskV_-1.0=0.66883647, learning_rate=0.001\n", + "Epoch 169/169 - loss=0.60296589, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62834781, MSE_maskV_-1.0=0.60286301, val_loss=0.66992491, val_CC_maskV_-1.0=0.59434032, val_MSE_maskV_-1.0=0.66655523, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:42:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 45.27s\n", + "\u001b[32m2025-05-30 11:42:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.66613925)\n", + "\u001b[32m2025-05-30 11:42:22\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 873us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:42:22\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.6, R2_maskV_-1.0=0.401, CC_maskV_-1.0=0.633\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 813us/step\n", + "51/51 [==============================] - 0s 777us/step\n", + "84/84 [==============================] - 0s 932us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:42:24\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_ACzCy1HL64U_ErSV16\" (14/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_ACzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:42:24\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_KCzCy1HL64U_ErSV16\" (15/16)\n", + "\u001b[32m2025-05-30 11:42:24\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:42:24\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:42:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:42:25\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:42:25\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:42:25\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:42:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:42:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 151 (stopped at 166 epochs).\n", + "\u001b[32m2025-05-30 11:42:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0014597, rnn_1step_R2_maskV_-1.0=-0.014132027, rnn_1step_CC_maskV_-1.0=0.058932111, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92266178, val_rnn_1step_R2_maskV_-1.0=-0.064026266, val_rnn_1step_CC_maskV_-1.0=0.29613841, learning_rate=0.001\n", + "Epoch 18/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.74007559, rnn_1step_R2_maskV_-1.0=0.24789408, rnn_1step_CC_maskV_-1.0=0.51732904, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.70699793, val_rnn_1step_R2_maskV_-1.0=0.17893814, val_rnn_1step_CC_maskV_-1.0=0.47757304, learning_rate=0.001\n", + "Epoch 35/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.51756883, rnn_1step_R2_maskV_-1.0=0.47435313, rnn_1step_CC_maskV_-1.0=0.69504392, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57426071, val_rnn_1step_R2_maskV_-1.0=0.32552564, val_rnn_1step_CC_maskV_-1.0=0.62503642, learning_rate=0.001\n", + "Epoch 52/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38667491, rnn_1step_R2_maskV_-1.0=0.60814357, rnn_1step_CC_maskV_-1.0=0.78286624, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52128559, val_rnn_1step_R2_maskV_-1.0=0.38911927, val_rnn_1step_CC_maskV_-1.0=0.67232513, learning_rate=0.001\n", + "Epoch 69/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29521224, rnn_1step_R2_maskV_-1.0=0.70179081, rnn_1step_CC_maskV_-1.0=0.83933192, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49472794, val_rnn_1step_R2_maskV_-1.0=0.42045787, val_rnn_1step_CC_maskV_-1.0=0.697339, learning_rate=0.001\n", + "Epoch 86/167 - loss=rnn_1step_loss=0.24934228, rnn_1step_R2_maskV_-1.0=0.74807489, rnn_1step_CC_maskV_-1.0=0.8662948, rnn_1step_MSE_maskV_-1.0=0.24934231, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48095796, val_rnn_1step_R2_maskV_-1.0=0.43679726, val_rnn_1step_CC_maskV_-1.0=0.71296769, learning_rate=0.001\n", + "Epoch 103/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.22208732, rnn_1step_R2_maskV_-1.0=0.77518094, rnn_1step_CC_maskV_-1.0=0.88183832, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47447526, val_rnn_1step_R2_maskV_-1.0=0.44506669, val_rnn_1step_CC_maskV_-1.0=0.7175864, learning_rate=0.001\n", + "Epoch 120/167 - loss=rnn_1step_loss=0.19584917, rnn_1step_R2_maskV_-1.0=0.80171835, rnn_1step_CC_maskV_-1.0=0.89677572, rnn_1step_MSE_maskV_-1.0=0.19584915, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46411291, val_rnn_1step_R2_maskV_-1.0=0.45778859, val_rnn_1step_CC_maskV_-1.0=0.72610295, learning_rate=0.001\n", + "Epoch 137/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.18200457, rnn_1step_R2_maskV_-1.0=0.81545025, rnn_1step_CC_maskV_-1.0=0.90414596, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45884216, val_rnn_1step_R2_maskV_-1.0=0.46547836, val_rnn_1step_CC_maskV_-1.0=0.73411012, learning_rate=0.001\n", + "Epoch 154/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.17090927, rnn_1step_R2_maskV_-1.0=0.82649857, rnn_1step_CC_maskV_-1.0=0.91041517, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4582707, val_rnn_1step_R2_maskV_-1.0=0.46561161, val_rnn_1step_CC_maskV_-1.0=0.73130697, learning_rate=0.001\n", + "Epoch 167/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.16551413, rnn_1step_R2_maskV_-1.0=0.83194482, rnn_1step_CC_maskV_-1.0=0.9131971, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46083489, val_rnn_1step_R2_maskV_-1.0=0.46382838, val_rnn_1step_CC_maskV_-1.0=0.73482007, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:42:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 18.88s\n", + "\u001b[32m2025-05-30 11:42:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:42:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 113 (stopped at 128 epochs).\n", + "\u001b[32m2025-05-30 11:42:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0015152, rnn_1_1step_R2_maskV_-1.0=-0.014182411, rnn_1_1step_CC_maskV_-1.0=0.040444978, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92299384, val_rnn_1_1step_R2_maskV_-1.0=-0.064438343, val_rnn_1_1step_CC_maskV_-1.0=0.25609803, learning_rate=0.001\n", + "Epoch 14/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.74054462, rnn_1_1step_R2_maskV_-1.0=0.24776629, rnn_1_1step_CC_maskV_-1.0=0.51532233, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.7204302, val_rnn_1_1step_R2_maskV_-1.0=0.16247106, val_rnn_1_1step_CC_maskV_-1.0=0.46754938, learning_rate=0.001\n", + "Epoch 27/129 - loss=rnn_1_1step_loss=0.57581592, rnn_1_1step_R2_maskV_-1.0=0.41333896, rnn_1_1step_CC_maskV_-1.0=0.65188777, rnn_1_1step_MSE_maskV_-1.0=0.57581598, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63685626, val_rnn_1_1step_R2_maskV_-1.0=0.25659704, val_rnn_1_1step_CC_maskV_-1.0=0.57222539, learning_rate=0.001\n", + "Epoch 40/129 - loss=rnn_1_1step_loss=0.46717516, rnn_1_1step_R2_maskV_-1.0=0.52568263, rnn_1_1step_CC_maskV_-1.0=0.72994602, rnn_1_1step_MSE_maskV_-1.0=0.46717522, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55851972, val_rnn_1_1step_R2_maskV_-1.0=0.34784377, val_rnn_1_1step_CC_maskV_-1.0=0.6415841, learning_rate=0.001\n", + "Epoch 53/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36525723, rnn_1_1step_R2_maskV_-1.0=0.62918997, rnn_1_1step_CC_maskV_-1.0=0.79685587, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51257747, val_rnn_1_1step_R2_maskV_-1.0=0.40005857, val_rnn_1_1step_CC_maskV_-1.0=0.68331611, learning_rate=0.001\n", + "Epoch 66/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31252033, rnn_1_1step_R2_maskV_-1.0=0.68264121, rnn_1_1step_CC_maskV_-1.0=0.82921523, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50423658, val_rnn_1_1step_R2_maskV_-1.0=0.40979311, val_rnn_1_1step_CC_maskV_-1.0=0.69287843, learning_rate=0.001\n", + "Epoch 79/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.2681284, rnn_1_1step_R2_maskV_-1.0=0.72791702, rnn_1_1step_CC_maskV_-1.0=0.85550922, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49460092, val_rnn_1_1step_R2_maskV_-1.0=0.42079294, val_rnn_1_1step_CC_maskV_-1.0=0.70352978, learning_rate=0.001\n", + "Epoch 92/129 - loss=rnn_1_1step_loss=0.23490024, rnn_1_1step_R2_maskV_-1.0=0.76183224, rnn_1_1step_CC_maskV_-1.0=0.87468928, rnn_1_1step_MSE_maskV_-1.0=0.23490027, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49085459, val_rnn_1_1step_R2_maskV_-1.0=0.42455894, val_rnn_1_1step_CC_maskV_-1.0=0.71100223, learning_rate=0.001\n", + "Epoch 105/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.20537956, rnn_1_1step_R2_maskV_-1.0=0.79173845, rnn_1_1step_CC_maskV_-1.0=0.89124286, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47386777, val_rnn_1_1step_R2_maskV_-1.0=0.4465985, val_rnn_1_1step_CC_maskV_-1.0=0.7243306, learning_rate=0.001\n", + "Epoch 118/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.18959649, rnn_1_1step_R2_maskV_-1.0=0.80769372, rnn_1_1step_CC_maskV_-1.0=0.9001869, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47088441, val_rnn_1_1step_R2_maskV_-1.0=0.45020586, val_rnn_1_1step_CC_maskV_-1.0=0.72652006, learning_rate=0.001\n", + "Epoch 129/129 - loss=rnn_1_1step_loss=0.18111287, rnn_1_1step_R2_maskV_-1.0=0.81625783, rnn_1_1step_CC_maskV_-1.0=0.90479892, rnn_1_1step_MSE_maskV_-1.0=0.18111286, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46423042, val_rnn_1_1step_R2_maskV_-1.0=0.45746371, val_rnn_1_1step_CC_maskV_-1.0=0.72926176, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:42:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.31s\n", + "\u001b[32m2025-05-30 11:42:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.45132652)\n", + "\u001b[32m2025-05-30 11:43:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.153, R2_maskV_-1.0=0.847, CC_maskV_-1.0=0.92\n", + "\u001b[32m2025-05-30 11:43:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.395, R2_maskV_-1.0=0.549, CC_maskV_-1.0=0.774\n", + "\u001b[32m2025-05-30 11:43:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:43:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:43:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 86 (stopped at 101 epochs).\n", + "\u001b[32m2025-05-30 11:43:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/102 - loss=1.4511747, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.066570066, MSE_maskV_-1.0=1.4502007, val_loss=1.0302116, val_CC_maskV_-1.0=0.16367891, val_MSE_maskV_-1.0=1.0261952, learning_rate=0.001\n", + "Epoch 12/102 - loss=0.8378666, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40334108, MSE_maskV_-1.0=0.83833665, val_loss=0.88586181, val_CC_maskV_-1.0=0.38417518, val_MSE_maskV_-1.0=0.88309526, learning_rate=0.001\n", + "Epoch 23/102 - loss=0.79726785, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45126981, MSE_maskV_-1.0=0.79714197, val_loss=0.85394323, val_CC_maskV_-1.0=0.42396989, val_MSE_maskV_-1.0=0.85104018, learning_rate=0.001\n", + "Epoch 34/102 - loss=0.77811259, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47199556, MSE_maskV_-1.0=0.77822453, val_loss=0.83352685, val_CC_maskV_-1.0=0.44568858, val_MSE_maskV_-1.0=0.83015388, learning_rate=0.001\n", + "Epoch 45/102 - loss=0.76439601, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48727247, MSE_maskV_-1.0=0.76401794, val_loss=0.82627904, val_CC_maskV_-1.0=0.45432103, val_MSE_maskV_-1.0=0.82292181, learning_rate=0.001\n", + "Epoch 56/102 - loss=0.75233251, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49834055, MSE_maskV_-1.0=0.75253195, val_loss=0.81516409, val_CC_maskV_-1.0=0.46685523, val_MSE_maskV_-1.0=0.81180155, learning_rate=0.001\n", + "Epoch 67/102 - loss=0.74243277, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50892538, MSE_maskV_-1.0=0.74205381, val_loss=0.81207812, val_CC_maskV_-1.0=0.47078481, val_MSE_maskV_-1.0=0.80830199, learning_rate=0.001\n", + "Epoch 78/102 - loss=0.73728985, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51335645, MSE_maskV_-1.0=0.73691374, val_loss=0.8074044, val_CC_maskV_-1.0=0.47558752, val_MSE_maskV_-1.0=0.80458951, learning_rate=0.001\n", + "Epoch 89/102 - loss=0.73272914, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51767111, MSE_maskV_-1.0=0.73317528, val_loss=0.80390239, val_CC_maskV_-1.0=0.47962663, val_MSE_maskV_-1.0=0.80081946, learning_rate=0.001\n", + "Epoch 100/102 - loss=0.72903317, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52104372, MSE_maskV_-1.0=0.72874302, val_loss=0.80452394, val_CC_maskV_-1.0=0.47869009, val_MSE_maskV_-1.0=0.80125082, learning_rate=0.001\n", + "Epoch 102/102 - loss=0.72908974, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.520872, MSE_maskV_-1.0=0.72951293, val_loss=0.80428678, val_CC_maskV_-1.0=0.47921953, val_MSE_maskV_-1.0=0.80092466, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:43:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 27.30s\n", + "\u001b[32m2025-05-30 11:43:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:43:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 86 (stopped at 101 epochs).\n", + "\u001b[32m2025-05-30 11:43:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/102 - loss=1.2724761, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.11890378, MSE_maskV_-1.0=1.2719012, val_loss=0.99888873, val_CC_maskV_-1.0=0.20556137, val_MSE_maskV_-1.0=0.99630618, learning_rate=0.001\n", + "Epoch 12/102 - loss=0.82569355, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41842902, MSE_maskV_-1.0=0.82616514, val_loss=0.87413347, val_CC_maskV_-1.0=0.39744386, val_MSE_maskV_-1.0=0.87163144, learning_rate=0.001\n", + "Epoch 23/102 - loss=0.79275966, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45623612, MSE_maskV_-1.0=0.79259038, val_loss=0.84531862, val_CC_maskV_-1.0=0.43286881, val_MSE_maskV_-1.0=0.84237552, learning_rate=0.001\n", + "Epoch 34/102 - loss=0.77351582, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47701794, MSE_maskV_-1.0=0.77366453, val_loss=0.82848358, val_CC_maskV_-1.0=0.45016521, val_MSE_maskV_-1.0=0.8254512, learning_rate=0.001\n", + "Epoch 45/102 - loss=0.76088148, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49090356, MSE_maskV_-1.0=0.76046115, val_loss=0.818277, val_CC_maskV_-1.0=0.46201789, val_MSE_maskV_-1.0=0.81518435, learning_rate=0.001\n", + "Epoch 56/102 - loss=0.75197744, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49864972, MSE_maskV_-1.0=0.75215721, val_loss=0.81275326, val_CC_maskV_-1.0=0.46882272, val_MSE_maskV_-1.0=0.80948526, learning_rate=0.001\n", + "Epoch 67/102 - loss=0.74346894, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50779039, MSE_maskV_-1.0=0.74310797, val_loss=0.80742991, val_CC_maskV_-1.0=0.47546682, val_MSE_maskV_-1.0=0.80413604, learning_rate=0.001\n", + "Epoch 78/102 - loss=0.73929209, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51138324, MSE_maskV_-1.0=0.73891377, val_loss=0.80430585, val_CC_maskV_-1.0=0.47842872, val_MSE_maskV_-1.0=0.80119884, learning_rate=0.001\n", + "Epoch 89/102 - loss=0.73491865, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51549041, MSE_maskV_-1.0=0.7353723, val_loss=0.80073625, val_CC_maskV_-1.0=0.48237863, val_MSE_maskV_-1.0=0.79771775, learning_rate=0.001\n", + "Epoch 100/102 - loss=0.73076713, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51929814, MSE_maskV_-1.0=0.73048115, val_loss=0.80252969, val_CC_maskV_-1.0=0.48072335, val_MSE_maskV_-1.0=0.79933131, learning_rate=0.001\n", + "Epoch 102/102 - loss=0.73149788, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51852369, MSE_maskV_-1.0=0.73186749, val_loss=0.80242336, val_CC_maskV_-1.0=0.48125705, val_MSE_maskV_-1.0=0.79907823, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:43:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 28.06s\n", + "\u001b[32m2025-05-30 11:43:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.79865336)\n", + "\u001b[32m2025-05-30 11:43:56\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 796us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:43:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.731, R2_maskV_-1.0=0.268, CC_maskV_-1.0=0.519\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 747us/step\n", + "51/51 [==============================] - 0s 816us/step\n", + "84/84 [==============================] - 0s 761us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:43:57\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_KCzCy1HL64U_ErSV16\" (15/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_KCzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:43:57\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16\" (16/16)\n", + "\u001b[32m2025-05-30 11:43:57\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:43:57\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:43:57\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:43:57\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:43:57\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:43:57\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:43:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:44:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 99 (stopped at 114 epochs).\n", + "\u001b[32m2025-05-30 11:44:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0015142, rnn_1step_R2_maskV_-1.0=-0.014183752, rnn_1step_CC_maskV_-1.0=0.033788312, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92320776, val_rnn_1step_R2_maskV_-1.0=-0.064683169, val_rnn_1step_CC_maskV_-1.0=0.29236203, learning_rate=0.001\n", + "Epoch 13/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.80670929, rnn_1step_R2_maskV_-1.0=0.18131162, rnn_1step_CC_maskV_-1.0=0.44270942, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.77367067, val_rnn_1step_R2_maskV_-1.0=0.10278223, val_rnn_1step_CC_maskV_-1.0=0.42040485, learning_rate=0.001\n", + "Epoch 25/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.61976486, rnn_1step_R2_maskV_-1.0=0.36609933, rnn_1step_CC_maskV_-1.0=0.61723781, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.68273765, val_rnn_1step_R2_maskV_-1.0=0.2075322, val_rnn_1step_CC_maskV_-1.0=0.52236438, learning_rate=0.001\n", + "Epoch 37/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.55000198, rnn_1step_R2_maskV_-1.0=0.43735868, rnn_1step_CC_maskV_-1.0=0.67138821, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64892274, val_rnn_1step_R2_maskV_-1.0=0.24868068, val_rnn_1step_CC_maskV_-1.0=0.55582619, learning_rate=0.001\n", + "Epoch 49/115 - loss=rnn_1step_loss=0.47626376, rnn_1step_R2_maskV_-1.0=0.51319277, rnn_1step_CC_maskV_-1.0=0.72457242, rnn_1step_MSE_maskV_-1.0=0.47626373, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58056664, val_rnn_1step_R2_maskV_-1.0=0.32566208, val_rnn_1step_CC_maskV_-1.0=0.61277145, learning_rate=0.001\n", + "Epoch 61/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41271153, rnn_1step_R2_maskV_-1.0=0.5791629, rnn_1step_CC_maskV_-1.0=0.76652849, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54821563, val_rnn_1step_R2_maskV_-1.0=0.35730422, val_rnn_1step_CC_maskV_-1.0=0.65669906, learning_rate=0.001\n", + "Epoch 73/115 - loss=rnn_1step_loss=0.35774979, rnn_1step_R2_maskV_-1.0=0.63550359, rnn_1step_CC_maskV_-1.0=0.80124974, rnn_1step_MSE_maskV_-1.0=0.35774976, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50881284, val_rnn_1step_R2_maskV_-1.0=0.40422785, val_rnn_1step_CC_maskV_-1.0=0.67974108, learning_rate=0.001\n", + "Epoch 85/115 - loss=rnn_1step_loss=0.3380183, rnn_1step_R2_maskV_-1.0=0.65563643, rnn_1step_CC_maskV_-1.0=0.81589198, rnn_1step_MSE_maskV_-1.0=0.33801827, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5159893, val_rnn_1step_R2_maskV_-1.0=0.3956033, val_rnn_1step_CC_maskV_-1.0=0.68034393, learning_rate=0.001\n", + "Epoch 97/115 - loss=rnn_1step_loss=0.3154411, rnn_1step_R2_maskV_-1.0=0.67928016, rnn_1step_CC_maskV_-1.0=0.82755256, rnn_1step_MSE_maskV_-1.0=0.31544107, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49813214, val_rnn_1step_R2_maskV_-1.0=0.41748157, val_rnn_1step_CC_maskV_-1.0=0.68973124, learning_rate=0.001\n", + "Epoch 109/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29674327, rnn_1step_R2_maskV_-1.0=0.69823593, rnn_1step_CC_maskV_-1.0=0.83863819, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50408131, val_rnn_1step_R2_maskV_-1.0=0.41073209, val_rnn_1step_CC_maskV_-1.0=0.69060367, learning_rate=0.001\n", + "Epoch 115/115 - loss=rnn_1step_loss=0.29234752, rnn_1step_R2_maskV_-1.0=0.70300674, rnn_1step_CC_maskV_-1.0=0.84114015, rnn_1step_MSE_maskV_-1.0=0.29234755, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.502918, val_rnn_1step_R2_maskV_-1.0=0.41136074, val_rnn_1step_CC_maskV_-1.0=0.68745214, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:44:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.52s\n", + "\u001b[32m2025-05-30 11:44:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:44:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 80 (stopped at 95 epochs).\n", + "\u001b[32m2025-05-30 11:44:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/96 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0015417, rnn_1_1step_R2_maskV_-1.0=-0.014211949, rnn_1_1step_CC_maskV_-1.0=0.032040823, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92271727, val_rnn_1_1step_R2_maskV_-1.0=-0.064116314, val_rnn_1_1step_CC_maskV_-1.0=0.24229389, learning_rate=0.001\n", + "Epoch 11/96 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.80840826, rnn_1_1step_R2_maskV_-1.0=0.17861706, rnn_1_1step_CC_maskV_-1.0=0.44761208, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.77744037, val_rnn_1_1step_R2_maskV_-1.0=0.097973049, val_rnn_1_1step_CC_maskV_-1.0=0.42006236, learning_rate=0.001\n", + "Epoch 21/96 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.63996536, rnn_1_1step_R2_maskV_-1.0=0.34473512, rnn_1_1step_CC_maskV_-1.0=0.60114312, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.67310077, val_rnn_1_1step_R2_maskV_-1.0=0.21719307, val_rnn_1_1step_CC_maskV_-1.0=0.53119576, learning_rate=0.001\n", + "Epoch 31/96 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.59739065, rnn_1_1step_R2_maskV_-1.0=0.38727853, rnn_1_1step_CC_maskV_-1.0=0.63537258, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.66797465, val_rnn_1_1step_R2_maskV_-1.0=0.22469313, val_rnn_1_1step_CC_maskV_-1.0=0.53163135, learning_rate=0.001\n", + "Epoch 41/96 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.54686791, rnn_1_1step_R2_maskV_-1.0=0.43881321, rnn_1_1step_CC_maskV_-1.0=0.67466801, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64258951, val_rnn_1_1step_R2_maskV_-1.0=0.2551989, val_rnn_1_1step_CC_maskV_-1.0=0.55425602, learning_rate=0.001\n", + "Epoch 51/96 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.49904004, rnn_1_1step_R2_maskV_-1.0=0.48802826, rnn_1_1step_CC_maskV_-1.0=0.70892233, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61346942, val_rnn_1_1step_R2_maskV_-1.0=0.28811601, val_rnn_1_1step_CC_maskV_-1.0=0.58247399, learning_rate=0.001\n", + "Epoch 61/96 - loss=rnn_1_1step_loss=0.43528819, rnn_1_1step_R2_maskV_-1.0=0.55407178, rnn_1_1step_CC_maskV_-1.0=0.7523489, rnn_1_1step_MSE_maskV_-1.0=0.43528816, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55937028, val_rnn_1_1step_R2_maskV_-1.0=0.34905589, val_rnn_1_1step_CC_maskV_-1.0=0.63026935, learning_rate=0.001\n", + "Epoch 71/96 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.37266919, rnn_1_1step_R2_maskV_-1.0=0.61870927, rnn_1_1step_CC_maskV_-1.0=0.79200411, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51317221, val_rnn_1_1step_R2_maskV_-1.0=0.39960167, val_rnn_1_1step_CC_maskV_-1.0=0.6728276, learning_rate=0.001\n", + "Epoch 81/96 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.3439928, rnn_1_1step_R2_maskV_-1.0=0.64865839, rnn_1_1step_CC_maskV_-1.0=0.80976355, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5082953, val_rnn_1_1step_R2_maskV_-1.0=0.40257555, val_rnn_1_1step_CC_maskV_-1.0=0.68726742, learning_rate=0.001\n", + "Epoch 91/96 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31552026, rnn_1_1step_R2_maskV_-1.0=0.67764843, rnn_1_1step_CC_maskV_-1.0=0.8267296, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5036425, val_rnn_1_1step_R2_maskV_-1.0=0.40933967, val_rnn_1_1step_CC_maskV_-1.0=0.68731344, learning_rate=0.001\n", + "Epoch 96/96 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30782327, rnn_1_1step_R2_maskV_-1.0=0.68561399, rnn_1_1step_CC_maskV_-1.0=0.83194089, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5010944, val_rnn_1_1step_R2_maskV_-1.0=0.41234314, val_rnn_1_1step_CC_maskV_-1.0=0.69089109, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:44:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.60s\n", + "\u001b[32m2025-05-30 11:44:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.48833069)\n", + "\u001b[32m2025-05-30 11:44:26\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.293, R2_maskV_-1.0=0.707, CC_maskV_-1.0=0.842\n", + "\u001b[32m2025-05-30 11:44:26\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.486, R2_maskV_-1.0=0.446, CC_maskV_-1.0=0.703\n", + "\u001b[32m2025-05-30 11:44:26\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:44:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:45:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 108 (stopped at 123 epochs).\n", + "\u001b[32m2025-05-30 11:45:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/124 - loss=1.1060474, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.15209429, MSE_maskV_-1.0=1.1059533, val_loss=0.98044866, val_CC_maskV_-1.0=0.22804405, val_MSE_maskV_-1.0=0.9788782, learning_rate=0.001\n", + "Epoch 14/124 - loss=0.82471794, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41955626, MSE_maskV_-1.0=0.82517779, val_loss=0.87125778, val_CC_maskV_-1.0=0.3932398, val_MSE_maskV_-1.0=0.86875331, learning_rate=0.001\n", + "Epoch 27/124 - loss=0.78684211, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46068627, MSE_maskV_-1.0=0.7867254, val_loss=0.83318317, val_CC_maskV_-1.0=0.43315741, val_MSE_maskV_-1.0=0.83073956, learning_rate=0.001\n", + "Epoch 40/124 - loss=0.76650733, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48215193, MSE_maskV_-1.0=0.76618439, val_loss=0.82150549, val_CC_maskV_-1.0=0.44542551, val_MSE_maskV_-1.0=0.81880873, learning_rate=0.001\n", + "Epoch 53/124 - loss=0.75373513, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49441153, MSE_maskV_-1.0=0.75315797, val_loss=0.81049556, val_CC_maskV_-1.0=0.45564213, val_MSE_maskV_-1.0=0.80867702, learning_rate=0.001\n", + "Epoch 66/124 - loss=0.74455673, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50363612, MSE_maskV_-1.0=0.74455434, val_loss=0.80282485, val_CC_maskV_-1.0=0.46478164, val_MSE_maskV_-1.0=0.80058789, learning_rate=0.001\n", + "Epoch 79/124 - loss=0.73669106, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51171052, MSE_maskV_-1.0=0.73641735, val_loss=0.79827034, val_CC_maskV_-1.0=0.46876147, val_MSE_maskV_-1.0=0.79639083, learning_rate=0.001\n", + "Epoch 92/124 - loss=0.73126906, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51596618, MSE_maskV_-1.0=0.73061323, val_loss=0.79807782, val_CC_maskV_-1.0=0.46980605, val_MSE_maskV_-1.0=0.79529983, learning_rate=0.001\n", + "Epoch 105/124 - loss=0.72571754, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52236903, MSE_maskV_-1.0=0.72577053, val_loss=0.79107124, val_CC_maskV_-1.0=0.47661176, val_MSE_maskV_-1.0=0.78886914, learning_rate=0.001\n", + "Epoch 118/124 - loss=0.72092432, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52692878, MSE_maskV_-1.0=0.72058499, val_loss=0.78966272, val_CC_maskV_-1.0=0.47800419, val_MSE_maskV_-1.0=0.78816628, learning_rate=0.001\n", + "Epoch 124/124 - loss=0.72033983, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52687585, MSE_maskV_-1.0=0.72002453, val_loss=0.78609979, val_CC_maskV_-1.0=0.48130459, val_MSE_maskV_-1.0=0.78392822, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:45:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 33.47s\n", + "\u001b[32m2025-05-30 11:45:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:45:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 90 (stopped at 105 epochs).\n", + "\u001b[32m2025-05-30 11:45:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/106 - loss=1.085736, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.14041702, MSE_maskV_-1.0=1.085694, val_loss=0.97426373, val_CC_maskV_-1.0=0.24418803, val_MSE_maskV_-1.0=0.97110891, learning_rate=0.001\n", + "Epoch 12/106 - loss=0.82868135, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41413203, MSE_maskV_-1.0=0.8292616, val_loss=0.87006778, val_CC_maskV_-1.0=0.39380172, val_MSE_maskV_-1.0=0.86779732, learning_rate=0.001\n", + "Epoch 23/106 - loss=0.79371881, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45324627, MSE_maskV_-1.0=0.79369777, val_loss=0.83797181, val_CC_maskV_-1.0=0.42485461, val_MSE_maskV_-1.0=0.83598596, learning_rate=0.001\n", + "Epoch 34/106 - loss=0.77160758, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47700533, MSE_maskV_-1.0=0.7717129, val_loss=0.82046634, val_CC_maskV_-1.0=0.44435051, val_MSE_maskV_-1.0=0.81804121, learning_rate=0.001\n", + "Epoch 45/106 - loss=0.75758171, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49094602, MSE_maskV_-1.0=0.75750291, val_loss=0.81097591, val_CC_maskV_-1.0=0.45502779, val_MSE_maskV_-1.0=0.80816787, learning_rate=0.001\n", + "Epoch 56/106 - loss=0.747163, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50110984, MSE_maskV_-1.0=0.7474829, val_loss=0.80050093, val_CC_maskV_-1.0=0.46631005, val_MSE_maskV_-1.0=0.79824454, learning_rate=0.001\n", + "Epoch 67/106 - loss=0.73861307, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50966495, MSE_maskV_-1.0=0.73820961, val_loss=0.79489112, val_CC_maskV_-1.0=0.47260207, val_MSE_maskV_-1.0=0.79283601, learning_rate=0.001\n", + "Epoch 78/106 - loss=0.73294747, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51395518, MSE_maskV_-1.0=0.73269212, val_loss=0.79768896, val_CC_maskV_-1.0=0.47025082, val_MSE_maskV_-1.0=0.79583585, learning_rate=0.001\n", + "Epoch 89/106 - loss=0.72763485, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51994431, MSE_maskV_-1.0=0.72792989, val_loss=0.78769124, val_CC_maskV_-1.0=0.47911689, val_MSE_maskV_-1.0=0.78565806, learning_rate=0.001\n", + "Epoch 100/106 - loss=0.72392118, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52217788, MSE_maskV_-1.0=0.7237286, val_loss=0.79295164, val_CC_maskV_-1.0=0.47460833, val_MSE_maskV_-1.0=0.79101759, learning_rate=0.001\n", + "Epoch 106/106 - loss=0.72170401, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52571851, MSE_maskV_-1.0=0.72148317, val_loss=0.78672558, val_CC_maskV_-1.0=0.48135498, val_MSE_maskV_-1.0=0.7843976, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:45:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 28.11s\n", + "\u001b[32m2025-05-30 11:45:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.78456807)\n", + "\u001b[32m2025-05-30 11:45:28\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 800us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:45:28\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.723, R2_maskV_-1.0=0.278, CC_maskV_-1.0=0.527\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 780us/step\n", + "51/51 [==============================] - 0s 816us/step\n", + "84/84 [==============================] - 0s 817us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:45:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16\" (16/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_uAKCzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:45:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1948] \u001b[1;30mINFO\u001b[0m Saving results for fold 2 as ..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4.p\n", + "\u001b[32m2025-05-30 11:45:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1381] \u001b[1;30mINFO\u001b[0m Fold 3/4: training samples: 8014, test samples=2672\n", + "\u001b[32m2025-05-30 11:45:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1754] \u001b[1;30mINFO\u001b[0m Running fold 3 (NTrain=8014, NTest=2672)\n", + "\u001b[32m2025-05-30 11:45:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1849] \u001b[1;30mINFO\u001b[0m Signal dimensions: y => (10686, 46), z => (10686, 4), u => None\n", + "\u001b[32m2025-05-30 11:45:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1856] \u001b[1;30mINFO\u001b[0m Method codes to fit: ['DPAD_RTR2_ErSV16', 'DPAD_RTR2_A1HL64U_ErSV16', 'DPAD_RTR2_K1HL64U_ErSV16', 'DPAD_RTR2_Cz1HL64U_ErSV16', 'DPAD_RTR2_Cy1HL64U_ErSV16', 'DPAD_RTR2_uAK1HL64U_ErSV16', 'DPAD_RTR2_ACz1HL64U_ErSV16', 'DPAD_RTR2_ACy1HL64U_ErSV16', 'DPAD_RTR2_KCz1HL64U_ErSV16', 'DPAD_RTR2_KCy1HL64U_ErSV16', 'DPAD_RTR2_CzCy1HL64U_ErSV16', 'DPAD_RTR2_uAKCz1HL64U_ErSV16', 'DPAD_RTR2_uAKCy1HL64U_ErSV16', 'DPAD_RTR2_ACzCy1HL64U_ErSV16', 'DPAD_RTR2_KCzCy1HL64U_ErSV16', 'DPAD_RTR2_uAKCzCy1HL64U_ErSV16']\n", + "\u001b[32m2025-05-30 11:45:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1857] \u001b[1;30mINFO\u001b[0m Nx values to fit: [16]\n", + "\u001b[32m2025-05-30 11:45:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_ErSV16\" (1/16)\n", + "\u001b[32m2025-05-30 11:45:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:45:29\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:45:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:45:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:45:29\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:45:29\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:45:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:45:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 145 (stopped at 160 epochs).\n", + "\u001b[32m2025-05-30 11:45:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/161 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0004715, rnn_1step_R2_maskV_-1.0=-0.011508074, rnn_1step_CC_maskV_-1.0=0.054319456, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91248727, val_rnn_1step_R2_maskV_-1.0=-0.054019749, val_rnn_1step_CC_maskV_-1.0=0.15268634, learning_rate=0.001\n", + "Epoch 18/161 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.68835419, rnn_1step_R2_maskV_-1.0=0.30014491, rnn_1step_CC_maskV_-1.0=0.56025285, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.67156178, val_rnn_1step_R2_maskV_-1.0=0.22060758, val_rnn_1step_CC_maskV_-1.0=0.52179408, learning_rate=0.001\n", + "Epoch 35/161 - loss=rnn_1step_loss=0.53314394, rnn_1step_R2_maskV_-1.0=0.45471212, rnn_1step_CC_maskV_-1.0=0.68296921, rnn_1step_MSE_maskV_-1.0=0.533144, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6154663, val_rnn_1step_R2_maskV_-1.0=0.28540012, val_rnn_1step_CC_maskV_-1.0=0.60101342, learning_rate=0.001\n", + "Epoch 52/161 - loss=rnn_1step_loss=0.49452457, rnn_1step_R2_maskV_-1.0=0.494874, rnn_1step_CC_maskV_-1.0=0.71073765, rnn_1step_MSE_maskV_-1.0=0.49452454, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60508078, val_rnn_1step_R2_maskV_-1.0=0.29605764, val_rnn_1step_CC_maskV_-1.0=0.61399424, learning_rate=0.001\n", + "Epoch 69/161 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.47890162, rnn_1step_R2_maskV_-1.0=0.5109812, rnn_1step_CC_maskV_-1.0=0.72170663, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59482521, val_rnn_1step_R2_maskV_-1.0=0.30800033, val_rnn_1step_CC_maskV_-1.0=0.62236351, learning_rate=0.001\n", + "Epoch 86/161 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.45547596, rnn_1step_R2_maskV_-1.0=0.53493297, rnn_1step_CC_maskV_-1.0=0.73777544, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57643968, val_rnn_1step_R2_maskV_-1.0=0.32975891, val_rnn_1step_CC_maskV_-1.0=0.63836873, learning_rate=0.001\n", + "Epoch 103/161 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.43153253, rnn_1step_R2_maskV_-1.0=0.5588789, rnn_1step_CC_maskV_-1.0=0.75380653, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55473572, val_rnn_1step_R2_maskV_-1.0=0.35546267, val_rnn_1step_CC_maskV_-1.0=0.65812308, learning_rate=0.001\n", + "Epoch 120/161 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42257705, rnn_1step_R2_maskV_-1.0=0.56768179, rnn_1step_CC_maskV_-1.0=0.75975263, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54997045, val_rnn_1step_R2_maskV_-1.0=0.36073682, val_rnn_1step_CC_maskV_-1.0=0.66437829, learning_rate=0.001\n", + "Epoch 137/161 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41810432, rnn_1step_R2_maskV_-1.0=0.57202357, rnn_1step_CC_maskV_-1.0=0.76266932, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54866642, val_rnn_1step_R2_maskV_-1.0=0.36210003, val_rnn_1step_CC_maskV_-1.0=0.66728461, learning_rate=0.001\n", + "Epoch 154/161 - loss=rnn_1step_loss=0.41596341, rnn_1step_R2_maskV_-1.0=0.57408208, rnn_1step_CC_maskV_-1.0=0.76405305, rnn_1step_MSE_maskV_-1.0=0.41596344, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54866189, val_rnn_1step_R2_maskV_-1.0=0.36205438, val_rnn_1step_CC_maskV_-1.0=0.66869473, learning_rate=0.001\n", + "Epoch 161/161 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41539168, rnn_1step_R2_maskV_-1.0=0.57462811, rnn_1step_CC_maskV_-1.0=0.76442176, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54886454, val_rnn_1step_R2_maskV_-1.0=0.36181372, val_rnn_1step_CC_maskV_-1.0=0.66899931, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:45:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.72s\n", + "\u001b[32m2025-05-30 11:45:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:45:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 134 (stopped at 149 epochs).\n", + "\u001b[32m2025-05-30 11:45:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/150 - loss=rnn_1_1step_loss=0.99958593, rnn_1_1step_R2_maskV_-1.0=-0.010824308, rnn_1_1step_CC_maskV_-1.0=0.075273417, rnn_1_1step_MSE_maskV_-1.0=0.99958599, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91313821, val_rnn_1_1step_R2_maskV_-1.0=-0.054738149, val_rnn_1_1step_CC_maskV_-1.0=0.16511571, learning_rate=0.001\n", + "Epoch 16/150 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.72844189, rnn_1_1step_R2_maskV_-1.0=0.2611421, rnn_1_1step_CC_maskV_-1.0=0.52422559, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.694004, val_rnn_1_1step_R2_maskV_-1.0=0.19327588, val_rnn_1_1step_CC_maskV_-1.0=0.49802116, learning_rate=0.001\n", + "Epoch 31/150 - loss=rnn_1_1step_loss=0.56577486, rnn_1_1step_R2_maskV_-1.0=0.42255574, rnn_1_1step_CC_maskV_-1.0=0.65848744, rnn_1_1step_MSE_maskV_-1.0=0.56577492, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62197161, val_rnn_1_1step_R2_maskV_-1.0=0.27777433, val_rnn_1_1step_CC_maskV_-1.0=0.58621055, learning_rate=0.001\n", + "Epoch 46/150 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.52891678, rnn_1_1step_R2_maskV_-1.0=0.45979702, rnn_1_1step_CC_maskV_-1.0=0.68617249, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61803812, val_rnn_1_1step_R2_maskV_-1.0=0.28295261, val_rnn_1_1step_CC_maskV_-1.0=0.59852511, learning_rate=0.001\n", + "Epoch 61/150 - loss=rnn_1_1step_loss=0.49826694, rnn_1_1step_R2_maskV_-1.0=0.4908728, rnn_1_1step_CC_maskV_-1.0=0.70814747, rnn_1_1step_MSE_maskV_-1.0=0.49826688, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60342336, val_rnn_1_1step_R2_maskV_-1.0=0.29912892, val_rnn_1_1step_CC_maskV_-1.0=0.61608189, learning_rate=0.001\n", + "Epoch 76/150 - loss=rnn_1_1step_loss=0.47363719, rnn_1_1step_R2_maskV_-1.0=0.51626885, rnn_1_1step_CC_maskV_-1.0=0.72521019, rnn_1_1step_MSE_maskV_-1.0=0.47363713, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58581406, val_rnn_1_1step_R2_maskV_-1.0=0.3192637, val_rnn_1_1step_CC_maskV_-1.0=0.63104808, learning_rate=0.001\n", + "Epoch 91/150 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44427857, rnn_1_1step_R2_maskV_-1.0=0.54629219, rnn_1_1step_CC_maskV_-1.0=0.7452327, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56161588, val_rnn_1_1step_R2_maskV_-1.0=0.34786782, val_rnn_1_1step_CC_maskV_-1.0=0.65053838, learning_rate=0.001\n", + "Epoch 106/150 - loss=rnn_1_1step_loss=0.42943814, rnn_1_1step_R2_maskV_-1.0=0.56101924, rnn_1_1step_CC_maskV_-1.0=0.75514609, rnn_1_1step_MSE_maskV_-1.0=0.42943811, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55164587, val_rnn_1_1step_R2_maskV_-1.0=0.35938084, val_rnn_1_1step_CC_maskV_-1.0=0.66082168, learning_rate=0.001\n", + "Epoch 121/150 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42199311, rnn_1_1step_R2_maskV_-1.0=0.56827873, rnn_1_1step_CC_maskV_-1.0=0.76003766, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54910463, val_rnn_1_1step_R2_maskV_-1.0=0.36205375, val_rnn_1_1step_CC_maskV_-1.0=0.66525739, learning_rate=0.001\n", + "Epoch 136/150 - loss=rnn_1_1step_loss=0.41799405, rnn_1_1step_R2_maskV_-1.0=0.57212776, rnn_1_1step_CC_maskV_-1.0=0.76263452, rnn_1_1step_MSE_maskV_-1.0=0.41799408, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54857236, val_rnn_1_1step_R2_maskV_-1.0=0.36249441, val_rnn_1_1step_CC_maskV_-1.0=0.66762668, learning_rate=0.001\n", + "Epoch 150/150 - loss=rnn_1_1step_loss=0.41594657, rnn_1_1step_R2_maskV_-1.0=0.574072, rnn_1_1step_CC_maskV_-1.0=0.76396173, rnn_1_1step_MSE_maskV_-1.0=0.41594654, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54905367, val_rnn_1_1step_R2_maskV_-1.0=0.36184886, val_rnn_1_1step_CC_maskV_-1.0=0.66861719, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:45:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.24s\n", + "\u001b[32m2025-05-30 11:46:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.54854017)\n", + "\u001b[32m2025-05-30 11:46:01\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.37, R2_maskV_-1.0=0.631, CC_maskV_-1.0=0.794\n", + "\u001b[32m2025-05-30 11:46:01\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.508, R2_maskV_-1.0=0.423, CC_maskV_-1.0=0.699\n", + "\u001b[32m2025-05-30 11:46:01\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:46:01\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:46:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 178 (stopped at 193 epochs).\n", + "\u001b[32m2025-05-30 11:46:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/194 - loss=3.4059947, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0096097281, MSE_maskV_-1.0=3.3994319, val_loss=1.3405334, val_CC_maskV_-1.0=0.042612497, val_MSE_maskV_-1.0=1.3339309, learning_rate=0.001\n", + "Epoch 21/194 - loss=0.84589988, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39392206, MSE_maskV_-1.0=0.84597135, val_loss=0.87191331, val_CC_maskV_-1.0=0.39354119, val_MSE_maskV_-1.0=0.86892515, learning_rate=0.001\n", + "Epoch 41/194 - loss=0.7967791, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45303205, MSE_maskV_-1.0=0.80125707, val_loss=0.82800382, val_CC_maskV_-1.0=0.44620001, val_MSE_maskV_-1.0=0.82505125, learning_rate=0.001\n", + "Epoch 61/194 - loss=0.77547419, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47690138, MSE_maskV_-1.0=0.77609307, val_loss=0.80737174, val_CC_maskV_-1.0=0.46749127, val_MSE_maskV_-1.0=0.80467117, learning_rate=0.001\n", + "Epoch 81/194 - loss=0.76215255, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48986012, MSE_maskV_-1.0=0.76242846, val_loss=0.79299039, val_CC_maskV_-1.0=0.48307449, val_MSE_maskV_-1.0=0.78992701, learning_rate=0.001\n", + "Epoch 101/194 - loss=0.7539764, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49724251, MSE_maskV_-1.0=0.75312436, val_loss=0.78754121, val_CC_maskV_-1.0=0.4879114, val_MSE_maskV_-1.0=0.78473079, learning_rate=0.001\n", + "Epoch 121/194 - loss=0.74811816, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50324714, MSE_maskV_-1.0=0.74801326, val_loss=0.77888823, val_CC_maskV_-1.0=0.49579844, val_MSE_maskV_-1.0=0.77588409, learning_rate=0.001\n", + "Epoch 141/194 - loss=0.74459839, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50666571, MSE_maskV_-1.0=0.74369204, val_loss=0.77439755, val_CC_maskV_-1.0=0.49927694, val_MSE_maskV_-1.0=0.77156866, learning_rate=0.001\n", + "Epoch 161/194 - loss=0.74125779, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50915498, MSE_maskV_-1.0=0.74126637, val_loss=0.77503932, val_CC_maskV_-1.0=0.49939376, val_MSE_maskV_-1.0=0.77211595, learning_rate=0.001\n", + "Epoch 181/194 - loss=0.73874724, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51195163, MSE_maskV_-1.0=0.73949677, val_loss=0.77106869, val_CC_maskV_-1.0=0.50235504, val_MSE_maskV_-1.0=0.76834732, learning_rate=0.001\n", + "Epoch 194/194 - loss=0.73719037, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51311457, MSE_maskV_-1.0=0.73791754, val_loss=0.77095765, val_CC_maskV_-1.0=0.50198334, val_MSE_maskV_-1.0=0.7681815, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:46:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 47.76s\n", + "\u001b[32m2025-05-30 11:46:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:47:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 178 (stopped at 193 epochs).\n", + "\u001b[32m2025-05-30 11:47:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/194 - loss=4.318892, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.014957628, MSE_maskV_-1.0=4.3094907, val_loss=1.4168818, val_CC_maskV_-1.0=0.04804391, val_MSE_maskV_-1.0=1.4140444, learning_rate=0.001\n", + "Epoch 21/194 - loss=0.84333795, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39701805, MSE_maskV_-1.0=0.84343421, val_loss=0.870592, val_CC_maskV_-1.0=0.3950184, val_MSE_maskV_-1.0=0.86744291, learning_rate=0.001\n", + "Epoch 41/194 - loss=0.79675657, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45282131, MSE_maskV_-1.0=0.80120593, val_loss=0.82822371, val_CC_maskV_-1.0=0.44599319, val_MSE_maskV_-1.0=0.82512957, learning_rate=0.001\n", + "Epoch 61/194 - loss=0.77576602, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47642943, MSE_maskV_-1.0=0.77638549, val_loss=0.8077296, val_CC_maskV_-1.0=0.46741796, val_MSE_maskV_-1.0=0.80488122, learning_rate=0.001\n", + "Epoch 81/194 - loss=0.76244467, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48951709, MSE_maskV_-1.0=0.76273704, val_loss=0.79331613, val_CC_maskV_-1.0=0.48306265, val_MSE_maskV_-1.0=0.79014713, learning_rate=0.001\n", + "Epoch 101/194 - loss=0.75412476, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.497159, MSE_maskV_-1.0=0.75327128, val_loss=0.7875312, val_CC_maskV_-1.0=0.48834404, val_MSE_maskV_-1.0=0.78464371, learning_rate=0.001\n", + "Epoch 121/194 - loss=0.74813718, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50327361, MSE_maskV_-1.0=0.74801242, val_loss=0.77868509, val_CC_maskV_-1.0=0.49637207, val_MSE_maskV_-1.0=0.77565241, learning_rate=0.001\n", + "Epoch 141/194 - loss=0.74457222, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50674212, MSE_maskV_-1.0=0.74367118, val_loss=0.77421784, val_CC_maskV_-1.0=0.49975508, val_MSE_maskV_-1.0=0.77136707, learning_rate=0.001\n", + "Epoch 161/194 - loss=0.74116027, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50929767, MSE_maskV_-1.0=0.74116719, val_loss=0.77466512, val_CC_maskV_-1.0=0.50003386, val_MSE_maskV_-1.0=0.77174574, learning_rate=0.001\n", + "Epoch 181/194 - loss=0.73863655, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51208824, MSE_maskV_-1.0=0.73938519, val_loss=0.77078909, val_CC_maskV_-1.0=0.50288528, val_MSE_maskV_-1.0=0.76807165, learning_rate=0.001\n", + "Epoch 194/194 - loss=0.73707414, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51328152, MSE_maskV_-1.0=0.73778462, val_loss=0.77064192, val_CC_maskV_-1.0=0.50250852, val_MSE_maskV_-1.0=0.76786804, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:47:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 47.97s\n", + "\u001b[32m2025-05-30 11:47:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.76673895)\n", + "\u001b[32m2025-05-30 11:47:36\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 757us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:47:37\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.736, R2_maskV_-1.0=0.264, CC_maskV_-1.0=0.515\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 817us/step\n", + "51/51 [==============================] - 0s 774us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:47:37\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_ErSV16\" (1/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:47:37\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_A1HL64U_ErSV16\" (2/16)\n", + "\u001b[32m2025-05-30 11:47:37\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_A1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:47:37\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:47:37\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:47:38\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:47:38\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:47:38\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:47:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:47:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 81 (stopped at 96 epochs).\n", + "\u001b[32m2025-05-30 11:47:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/97 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0001392, rnn_1step_R2_maskV_-1.0=-0.011132002, rnn_1step_CC_maskV_-1.0=0.059216943, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91191167, val_rnn_1step_R2_maskV_-1.0=-0.053326741, val_rnn_1step_CC_maskV_-1.0=0.16231149, learning_rate=0.001\n", + "Epoch 11/97 - loss=rnn_1step_loss=0.84530133, rnn_1step_R2_maskV_-1.0=0.14059043, rnn_1step_CC_maskV_-1.0=0.39474544, rnn_1step_MSE_maskV_-1.0=0.84530127, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.78021699, val_rnn_1step_R2_maskV_-1.0=0.094021156, val_rnn_1step_CC_maskV_-1.0=0.39440137, learning_rate=0.001\n", + "Epoch 21/97 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.68998247, rnn_1step_R2_maskV_-1.0=0.29702756, rnn_1step_CC_maskV_-1.0=0.55764818, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.69617367, val_rnn_1step_R2_maskV_-1.0=0.19164577, val_rnn_1step_CC_maskV_-1.0=0.49698147, learning_rate=0.001\n", + "Epoch 31/97 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.58457768, rnn_1step_R2_maskV_-1.0=0.40209615, rnn_1step_CC_maskV_-1.0=0.64415997, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.65088791, val_rnn_1step_R2_maskV_-1.0=0.24342865, val_rnn_1step_CC_maskV_-1.0=0.55667919, learning_rate=0.001\n", + "Epoch 41/97 - loss=rnn_1step_loss=0.53331751, rnn_1step_R2_maskV_-1.0=0.4537259, rnn_1step_CC_maskV_-1.0=0.68275607, rnn_1step_MSE_maskV_-1.0=0.53331757, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64360601, val_rnn_1step_R2_maskV_-1.0=0.25212485, val_rnn_1step_CC_maskV_-1.0=0.57264942, learning_rate=0.001\n", + "Epoch 51/97 - loss=rnn_1step_loss=0.49529156, rnn_1step_R2_maskV_-1.0=0.4915624, rnn_1step_CC_maskV_-1.0=0.71007711, rnn_1step_MSE_maskV_-1.0=0.49529153, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63443613, val_rnn_1step_R2_maskV_-1.0=0.26233089, val_rnn_1step_CC_maskV_-1.0=0.5903098, learning_rate=0.001\n", + "Epoch 61/97 - loss=rnn_1step_loss=0.4522076, rnn_1step_R2_maskV_-1.0=0.53496724, rnn_1step_CC_maskV_-1.0=0.73972368, rnn_1step_MSE_maskV_-1.0=0.45220762, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62100738, val_rnn_1step_R2_maskV_-1.0=0.27771777, val_rnn_1step_CC_maskV_-1.0=0.61024541, learning_rate=0.001\n", + "Epoch 71/97 - loss=rnn_1step_loss=0.42409351, rnn_1step_R2_maskV_-1.0=0.56343567, rnn_1step_CC_maskV_-1.0=0.75838029, rnn_1step_MSE_maskV_-1.0=0.42409354, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61592144, val_rnn_1step_R2_maskV_-1.0=0.28337732, val_rnn_1step_CC_maskV_-1.0=0.62229222, learning_rate=0.001\n", + "Epoch 81/97 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41321468, rnn_1step_R2_maskV_-1.0=0.57421672, rnn_1step_CC_maskV_-1.0=0.76603866, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58744133, val_rnn_1step_R2_maskV_-1.0=0.31675506, val_rnn_1step_CC_maskV_-1.0=0.63480866, learning_rate=0.001\n", + "Epoch 91/97 - loss=rnn_1step_loss=0.4012157, rnn_1step_R2_maskV_-1.0=0.58657402, rnn_1step_CC_maskV_-1.0=0.77352566, rnn_1step_MSE_maskV_-1.0=0.40121573, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6102488, val_rnn_1step_R2_maskV_-1.0=0.29015547, val_rnn_1step_CC_maskV_-1.0=0.6286177, learning_rate=0.001\n", + "Epoch 97/97 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39423466, rnn_1step_R2_maskV_-1.0=0.59329486, rnn_1step_CC_maskV_-1.0=0.77805972, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59852237, val_rnn_1step_R2_maskV_-1.0=0.30392414, val_rnn_1step_CC_maskV_-1.0=0.63481563, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:47:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.45s\n", + "\u001b[32m2025-05-30 11:47:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:48:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 105 (stopped at 120 epochs).\n", + "\u001b[32m2025-05-30 11:48:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/121 - loss=rnn_1_1step_loss=1.0024909, rnn_1_1step_R2_maskV_-1.0=-0.013753701, rnn_1_1step_CC_maskV_-1.0=0.0082865357, rnn_1_1step_MSE_maskV_-1.0=1.0024908, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.9124642, val_rnn_1_1step_R2_maskV_-1.0=-0.05392617, val_rnn_1_1step_CC_maskV_-1.0=0.17483744, learning_rate=0.001\n", + "Epoch 14/121 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.74972486, rnn_1_1step_R2_maskV_-1.0=0.2397148, rnn_1_1step_CC_maskV_-1.0=0.4998062, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.72218305, val_rnn_1_1step_R2_maskV_-1.0=0.16187127, val_rnn_1_1step_CC_maskV_-1.0=0.46789199, learning_rate=0.001\n", + "Epoch 27/121 - loss=rnn_1_1step_loss=0.59857124, rnn_1_1step_R2_maskV_-1.0=0.38994542, rnn_1_1step_CC_maskV_-1.0=0.63343072, rnn_1_1step_MSE_maskV_-1.0=0.59857118, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65936071, val_rnn_1_1step_R2_maskV_-1.0=0.23575108, val_rnn_1_1step_CC_maskV_-1.0=0.54312062, learning_rate=0.001\n", + "Epoch 40/121 - loss=rnn_1_1step_loss=0.53896552, rnn_1_1step_R2_maskV_-1.0=0.4484404, rnn_1_1step_CC_maskV_-1.0=0.67857492, rnn_1_1step_MSE_maskV_-1.0=0.53896546, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65291786, val_rnn_1_1step_R2_maskV_-1.0=0.24396254, val_rnn_1_1step_CC_maskV_-1.0=0.56553936, learning_rate=0.001\n", + "Epoch 53/121 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.50174743, rnn_1_1step_R2_maskV_-1.0=0.48560536, rnn_1_1step_CC_maskV_-1.0=0.70540297, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64510989, val_rnn_1_1step_R2_maskV_-1.0=0.25276935, val_rnn_1_1step_CC_maskV_-1.0=0.58063233, learning_rate=0.001\n", + "Epoch 66/121 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.46351752, rnn_1_1step_R2_maskV_-1.0=0.5238626, rnn_1_1step_CC_maskV_-1.0=0.73191297, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63521606, val_rnn_1_1step_R2_maskV_-1.0=0.26350865, val_rnn_1_1step_CC_maskV_-1.0=0.59765196, learning_rate=0.001\n", + "Epoch 79/121 - loss=rnn_1_1step_loss=0.42597094, rnn_1_1step_R2_maskV_-1.0=0.56115735, rnn_1_1step_CC_maskV_-1.0=0.75715643, rnn_1_1step_MSE_maskV_-1.0=0.42597097, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59893227, val_rnn_1_1step_R2_maskV_-1.0=0.30447438, val_rnn_1_1step_CC_maskV_-1.0=0.63024038, learning_rate=0.001\n", + "Epoch 92/121 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40772173, rnn_1_1step_R2_maskV_-1.0=0.57973677, rnn_1_1step_CC_maskV_-1.0=0.76947957, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58226895, val_rnn_1_1step_R2_maskV_-1.0=0.32394475, val_rnn_1_1step_CC_maskV_-1.0=0.64103866, learning_rate=0.001\n", + "Epoch 105/121 - loss=rnn_1_1step_loss=0.39378607, rnn_1_1step_R2_maskV_-1.0=0.59388781, rnn_1_1step_CC_maskV_-1.0=0.77843583, rnn_1_1step_MSE_maskV_-1.0=0.3937861, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56987953, val_rnn_1_1step_R2_maskV_-1.0=0.33837712, val_rnn_1_1step_CC_maskV_-1.0=0.64905214, learning_rate=0.001\n", + "Epoch 118/121 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38217676, rnn_1_1step_R2_maskV_-1.0=0.60579848, rnn_1_1step_CC_maskV_-1.0=0.78610581, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58229142, val_rnn_1_1step_R2_maskV_-1.0=0.32416576, val_rnn_1_1step_CC_maskV_-1.0=0.64416569, learning_rate=0.001\n", + "Epoch 121/121 - loss=rnn_1_1step_loss=0.37910852, rnn_1_1step_R2_maskV_-1.0=0.60880476, rnn_1_1step_CC_maskV_-1.0=0.78807884, rnn_1_1step_MSE_maskV_-1.0=0.37910846, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5785833, val_rnn_1_1step_R2_maskV_-1.0=0.32824764, val_rnn_1_1step_CC_maskV_-1.0=0.64632231, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:48:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 22.46s\n", + "\u001b[32m2025-05-30 11:48:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.56987953)\n", + "\u001b[32m2025-05-30 11:48:14\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.362, R2_maskV_-1.0=0.637, CC_maskV_-1.0=0.799\n", + "\u001b[32m2025-05-30 11:48:15\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.545, R2_maskV_-1.0=0.381, CC_maskV_-1.0=0.67\n", + "\u001b[32m2025-05-30 11:48:15\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:48:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:48:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 104 (stopped at 119 epochs).\n", + "\u001b[32m2025-05-30 11:48:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/120 - loss=1.8249955, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.066124089, MSE_maskV_-1.0=1.8234162, val_loss=1.1612436, val_CC_maskV_-1.0=0.11181197, val_MSE_maskV_-1.0=1.1598967, learning_rate=0.001\n", + "Epoch 13/120 - loss=0.80434525, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44535965, MSE_maskV_-1.0=0.80349177, val_loss=0.82795, val_CC_maskV_-1.0=0.4452042, val_MSE_maskV_-1.0=0.82480973, learning_rate=0.001\n", + "Epoch 25/120 - loss=0.76047224, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49116567, MSE_maskV_-1.0=0.76023418, val_loss=0.78727704, val_CC_maskV_-1.0=0.48619574, val_MSE_maskV_-1.0=0.78446293, learning_rate=0.001\n", + "Epoch 37/120 - loss=0.74332684, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50764143, MSE_maskV_-1.0=0.74316913, val_loss=0.7685709, val_CC_maskV_-1.0=0.50278747, val_MSE_maskV_-1.0=0.76581126, learning_rate=0.001\n", + "Epoch 49/120 - loss=0.73548532, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5148136, MSE_maskV_-1.0=0.7359401, val_loss=0.76229256, val_CC_maskV_-1.0=0.50822943, val_MSE_maskV_-1.0=0.75912505, learning_rate=0.001\n", + "Epoch 61/120 - loss=0.73184484, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51818156, MSE_maskV_-1.0=0.73243189, val_loss=0.75980073, val_CC_maskV_-1.0=0.50987929, val_MSE_maskV_-1.0=0.75702083, learning_rate=0.001\n", + "Epoch 73/120 - loss=0.72967941, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5191744, MSE_maskV_-1.0=0.72981328, val_loss=0.75775534, val_CC_maskV_-1.0=0.5113855, val_MSE_maskV_-1.0=0.7548303, learning_rate=0.001\n", + "Epoch 85/120 - loss=0.72823399, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5206756, MSE_maskV_-1.0=0.72840965, val_loss=0.75766629, val_CC_maskV_-1.0=0.5114882, val_MSE_maskV_-1.0=0.75485182, learning_rate=0.001\n", + "Epoch 97/120 - loss=0.72781903, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52088392, MSE_maskV_-1.0=0.72829646, val_loss=0.75532484, val_CC_maskV_-1.0=0.51386929, val_MSE_maskV_-1.0=0.75262237, learning_rate=0.001\n", + "Epoch 109/120 - loss=0.72722465, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52140307, MSE_maskV_-1.0=0.72688895, val_loss=0.754022, val_CC_maskV_-1.0=0.51506346, val_MSE_maskV_-1.0=0.75147766, learning_rate=0.001\n", + "Epoch 120/120 - loss=0.72722077, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52149391, MSE_maskV_-1.0=0.72681946, val_loss=0.7547648, val_CC_maskV_-1.0=0.51473534, val_MSE_maskV_-1.0=0.7519632, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:48:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 30.08s\n", + "\u001b[32m2025-05-30 11:48:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:49:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 104 (stopped at 119 epochs).\n", + "\u001b[32m2025-05-30 11:49:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/120 - loss=1.7256082, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.06679751, MSE_maskV_-1.0=1.7238823, val_loss=1.1515005, val_CC_maskV_-1.0=0.10295425, val_MSE_maskV_-1.0=1.1494465, learning_rate=0.001\n", + "Epoch 13/120 - loss=0.80730593, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4424248, MSE_maskV_-1.0=0.8064329, val_loss=0.82960373, val_CC_maskV_-1.0=0.44398665, val_MSE_maskV_-1.0=0.8265776, learning_rate=0.001\n", + "Epoch 25/120 - loss=0.7608735, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49088445, MSE_maskV_-1.0=0.7606439, val_loss=0.78731066, val_CC_maskV_-1.0=0.48631716, val_MSE_maskV_-1.0=0.78478593, learning_rate=0.001\n", + "Epoch 37/120 - loss=0.7433188, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50765771, MSE_maskV_-1.0=0.74318624, val_loss=0.76854283, val_CC_maskV_-1.0=0.50281149, val_MSE_maskV_-1.0=0.76606929, learning_rate=0.001\n", + "Epoch 49/120 - loss=0.73536694, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5149321, MSE_maskV_-1.0=0.73581672, val_loss=0.76225883, val_CC_maskV_-1.0=0.50830144, val_MSE_maskV_-1.0=0.75931627, learning_rate=0.001\n", + "Epoch 61/120 - loss=0.73171902, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51832366, MSE_maskV_-1.0=0.73231035, val_loss=0.75983387, val_CC_maskV_-1.0=0.50983804, val_MSE_maskV_-1.0=0.7572521, learning_rate=0.001\n", + "Epoch 73/120 - loss=0.72956836, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51928568, MSE_maskV_-1.0=0.72970527, val_loss=0.75783855, val_CC_maskV_-1.0=0.51126546, val_MSE_maskV_-1.0=0.75508726, learning_rate=0.001\n", + "Epoch 85/120 - loss=0.72815043, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52075744, MSE_maskV_-1.0=0.72832775, val_loss=0.75770038, val_CC_maskV_-1.0=0.51144016, val_MSE_maskV_-1.0=0.75501251, learning_rate=0.001\n", + "Epoch 97/120 - loss=0.72776031, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52094036, MSE_maskV_-1.0=0.72823828, val_loss=0.75533897, val_CC_maskV_-1.0=0.51383883, val_MSE_maskV_-1.0=0.75274682, learning_rate=0.001\n", + "Epoch 109/120 - loss=0.72718191, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52144545, MSE_maskV_-1.0=0.72684836, val_loss=0.75407487, val_CC_maskV_-1.0=0.51499808, val_MSE_maskV_-1.0=0.75161415, learning_rate=0.001\n", + "Epoch 120/120 - loss=0.7271896, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52153218, MSE_maskV_-1.0=0.72678912, val_loss=0.75482428, val_CC_maskV_-1.0=0.5146566, val_MSE_maskV_-1.0=0.75209397, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:49:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 29.96s\n", + "\u001b[32m2025-05-30 11:49:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.75401378)\n", + "\u001b[32m2025-05-30 11:49:15\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 776us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:49:15\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.726, R2_maskV_-1.0=0.274, CC_maskV_-1.0=0.524\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 708us/step\n", + "51/51 [==============================] - 0s 741us/step\n", + "84/84 [==============================] - 0s 676us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:49:16\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_A1HL64U_ErSV16\" (2/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_A1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:49:16\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_K1HL64U_ErSV16\" (3/16)\n", + "\u001b[32m2025-05-30 11:49:16\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_K1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:49:16\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:49:16\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:49:16\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:49:16\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:49:16\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:49:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:49:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 71 (stopped at 86 epochs).\n", + "\u001b[32m2025-05-30 11:49:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/87 - loss=rnn_1step_loss=1.0019583, rnn_1step_R2_maskV_-1.0=-0.013260238, rnn_1step_CC_maskV_-1.0=0.060740635, rnn_1step_MSE_maskV_-1.0=1.0019581, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91615319, val_rnn_1step_R2_maskV_-1.0=-0.058055237, val_rnn_1step_CC_maskV_-1.0=0.2906749, learning_rate=0.001\n", + "Epoch 10/87 - loss=rnn_1step_loss=0.87195396, rnn_1step_R2_maskV_-1.0=0.11816441, rnn_1step_CC_maskV_-1.0=0.41732961, rnn_1step_MSE_maskV_-1.0=0.8719539, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.79448456, val_rnn_1step_R2_maskV_-1.0=0.079891622, val_rnn_1step_CC_maskV_-1.0=0.39841807, learning_rate=0.001\n", + "Epoch 19/87 - loss=rnn_1step_loss=0.61831754, rnn_1step_R2_maskV_-1.0=0.36933711, rnn_1step_CC_maskV_-1.0=0.61752748, rnn_1step_MSE_maskV_-1.0=0.61831748, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6342988, val_rnn_1step_R2_maskV_-1.0=0.26414675, val_rnn_1step_CC_maskV_-1.0=0.56222147, learning_rate=0.001\n", + "Epoch 28/87 - loss=rnn_1step_loss=0.49938473, rnn_1step_R2_maskV_-1.0=0.48828086, rnn_1step_CC_maskV_-1.0=0.70690477, rnn_1step_MSE_maskV_-1.0=0.4993847, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59413821, val_rnn_1step_R2_maskV_-1.0=0.31093284, val_rnn_1step_CC_maskV_-1.0=0.61139768, learning_rate=0.001\n", + "Epoch 37/87 - loss=rnn_1step_loss=0.42340836, rnn_1step_R2_maskV_-1.0=0.56597948, rnn_1step_CC_maskV_-1.0=0.75895655, rnn_1step_MSE_maskV_-1.0=0.42340833, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55205774, val_rnn_1step_R2_maskV_-1.0=0.35892576, val_rnn_1step_CC_maskV_-1.0=0.65055758, learning_rate=0.001\n", + "Epoch 46/87 - loss=rnn_1step_loss=0.37668109, rnn_1step_R2_maskV_-1.0=0.61388081, rnn_1step_CC_maskV_-1.0=0.78913325, rnn_1step_MSE_maskV_-1.0=0.37668103, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5245381, val_rnn_1step_R2_maskV_-1.0=0.39025098, val_rnn_1step_CC_maskV_-1.0=0.67189395, learning_rate=0.001\n", + "Epoch 55/87 - loss=rnn_1step_loss=0.34121606, rnn_1step_R2_maskV_-1.0=0.65051806, rnn_1step_CC_maskV_-1.0=0.81127059, rnn_1step_MSE_maskV_-1.0=0.34121603, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50903237, val_rnn_1step_R2_maskV_-1.0=0.40839171, val_rnn_1step_CC_maskV_-1.0=0.68578851, learning_rate=0.001\n", + "Epoch 64/87 - loss=rnn_1step_loss=0.29794082, rnn_1step_R2_maskV_-1.0=0.69520915, rnn_1step_CC_maskV_-1.0=0.83765161, rnn_1step_MSE_maskV_-1.0=0.29794079, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48600188, val_rnn_1step_R2_maskV_-1.0=0.43572485, val_rnn_1step_CC_maskV_-1.0=0.70613265, learning_rate=0.001\n", + "Epoch 73/87 - loss=rnn_1step_loss=0.26051971, rnn_1step_R2_maskV_-1.0=0.73316956, rnn_1step_CC_maskV_-1.0=0.85986853, rnn_1step_MSE_maskV_-1.0=0.26051974, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47600117, val_rnn_1step_R2_maskV_-1.0=0.44759604, val_rnn_1step_CC_maskV_-1.0=0.71845275, learning_rate=0.001\n", + "Epoch 82/87 - loss=rnn_1step_loss=0.24013574, rnn_1step_R2_maskV_-1.0=0.75381845, rnn_1step_CC_maskV_-1.0=0.87174392, rnn_1step_MSE_maskV_-1.0=0.24013576, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49137616, val_rnn_1step_R2_maskV_-1.0=0.42951164, val_rnn_1step_CC_maskV_-1.0=0.71497303, learning_rate=0.001\n", + "Epoch 87/87 - loss=rnn_1step_loss=0.23143415, rnn_1step_R2_maskV_-1.0=0.76264149, rnn_1step_CC_maskV_-1.0=0.87675017, rnn_1step_MSE_maskV_-1.0=0.23143414, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50122446, val_rnn_1step_R2_maskV_-1.0=0.41800579, val_rnn_1step_CC_maskV_-1.0=0.7120856, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:49:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.22s\n", + "\u001b[32m2025-05-30 11:49:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:49:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 77 (stopped at 92 epochs).\n", + "\u001b[32m2025-05-30 11:49:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/93 - loss=rnn_1_1step_loss=1.0018052, rnn_1_1step_R2_maskV_-1.0=-0.013097394, rnn_1_1step_CC_maskV_-1.0=0.091251329, rnn_1_1step_MSE_maskV_-1.0=1.0018053, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91757804, val_rnn_1_1step_R2_maskV_-1.0=-0.059774265, val_rnn_1_1step_CC_maskV_-1.0=0.22592983, learning_rate=0.001\n", + "Epoch 11/93 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.82985401, rnn_1_1step_R2_maskV_-1.0=0.15848847, rnn_1_1step_CC_maskV_-1.0=0.43183973, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.78547519, val_rnn_1_1step_R2_maskV_-1.0=0.088113278, val_rnn_1_1step_CC_maskV_-1.0=0.38966107, learning_rate=0.001\n", + "Epoch 21/93 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.6082744, rnn_1_1step_R2_maskV_-1.0=0.3778179, rnn_1_1step_CC_maskV_-1.0=0.62785935, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64163041, val_rnn_1_1step_R2_maskV_-1.0=0.2555995, val_rnn_1_1step_CC_maskV_-1.0=0.56395662, learning_rate=0.001\n", + "Epoch 31/93 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.50376964, rnn_1_1step_R2_maskV_-1.0=0.48321211, rnn_1_1step_CC_maskV_-1.0=0.70383257, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59166759, val_rnn_1_1step_R2_maskV_-1.0=0.31361568, val_rnn_1_1step_CC_maskV_-1.0=0.61484772, learning_rate=0.001\n", + "Epoch 41/93 - loss=rnn_1_1step_loss=0.43917522, rnn_1_1step_R2_maskV_-1.0=0.54888463, rnn_1_1step_CC_maskV_-1.0=0.74838328, rnn_1_1step_MSE_maskV_-1.0=0.43917519, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56284761, val_rnn_1_1step_R2_maskV_-1.0=0.34703016, val_rnn_1_1step_CC_maskV_-1.0=0.6440239, learning_rate=0.001\n", + "Epoch 51/93 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.3726646, rnn_1_1step_R2_maskV_-1.0=0.61773407, rnn_1_1step_CC_maskV_-1.0=0.79175067, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52978522, val_rnn_1_1step_R2_maskV_-1.0=0.38442394, val_rnn_1_1step_CC_maskV_-1.0=0.67417055, learning_rate=0.001\n", + "Epoch 61/93 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33369794, rnn_1_1step_R2_maskV_-1.0=0.65821135, rnn_1_1step_CC_maskV_-1.0=0.81602824, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50261682, val_rnn_1_1step_R2_maskV_-1.0=0.4160988, val_rnn_1_1step_CC_maskV_-1.0=0.69631708, learning_rate=0.001\n", + "Epoch 71/93 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.28676197, rnn_1_1step_R2_maskV_-1.0=0.70631897, rnn_1_1step_CC_maskV_-1.0=0.84446287, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47238326, val_rnn_1_1step_R2_maskV_-1.0=0.45171696, val_rnn_1_1step_CC_maskV_-1.0=0.72023499, learning_rate=0.001\n", + "Epoch 81/93 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.2533901, rnn_1_1step_R2_maskV_-1.0=0.74040252, rnn_1_1step_CC_maskV_-1.0=0.86417329, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46402201, val_rnn_1_1step_R2_maskV_-1.0=0.46131384, val_rnn_1_1step_CC_maskV_-1.0=0.72917736, learning_rate=0.001\n", + "Epoch 91/93 - loss=rnn_1_1step_loss=0.23519985, rnn_1_1step_R2_maskV_-1.0=0.75904715, rnn_1_1step_CC_maskV_-1.0=0.87466788, rnn_1_1step_MSE_maskV_-1.0=0.23519987, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47277895, val_rnn_1_1step_R2_maskV_-1.0=0.4512344, val_rnn_1_1step_CC_maskV_-1.0=0.72806567, learning_rate=0.001\n", + "Epoch 93/93 - loss=rnn_1_1step_loss=0.23267435, rnn_1_1step_R2_maskV_-1.0=0.76167315, rnn_1_1step_CC_maskV_-1.0=0.87610668, rnn_1_1step_MSE_maskV_-1.0=0.23267433, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4747659, val_rnn_1_1step_R2_maskV_-1.0=0.44875127, val_rnn_1_1step_CC_maskV_-1.0=0.72683275, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:49:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.80s\n", + "\u001b[32m2025-05-30 11:49:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.4623622)\n", + "\u001b[32m2025-05-30 11:49:38\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.234, R2_maskV_-1.0=0.767, CC_maskV_-1.0=0.875\n", + "\u001b[32m2025-05-30 11:49:39\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.433, R2_maskV_-1.0=0.51, CC_maskV_-1.0=0.751\n", + "\u001b[32m2025-05-30 11:49:39\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:49:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:50:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 308 (stopped at 323 epochs).\n", + "\u001b[32m2025-05-30 11:50:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/324 - loss=1.7614139, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.020497346, MSE_maskV_-1.0=1.7595519, val_loss=1.0702702, val_CC_maskV_-1.0=0.094798088, val_MSE_maskV_-1.0=1.0670328, learning_rate=0.001\n", + "Epoch 34/324 - loss=0.89596933, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.33096051, MSE_maskV_-1.0=0.89527094, val_loss=0.92247593, val_CC_maskV_-1.0=0.33597195, val_MSE_maskV_-1.0=0.91915941, learning_rate=0.001\n", + "Epoch 67/324 - loss=0.87097943, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36761615, MSE_maskV_-1.0=0.87057161, val_loss=0.89948213, val_CC_maskV_-1.0=0.36916232, val_MSE_maskV_-1.0=0.89589643, learning_rate=0.001\n", + "Epoch 100/324 - loss=0.85653967, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38537192, MSE_maskV_-1.0=0.85678911, val_loss=0.88494498, val_CC_maskV_-1.0=0.38673443, val_MSE_maskV_-1.0=0.88171542, learning_rate=0.001\n", + "Epoch 133/324 - loss=0.84693527, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3972322, MSE_maskV_-1.0=0.84671831, val_loss=0.87587816, val_CC_maskV_-1.0=0.39734802, val_MSE_maskV_-1.0=0.8724823, learning_rate=0.001\n", + "Epoch 166/324 - loss=0.83939052, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40682569, MSE_maskV_-1.0=0.83988196, val_loss=0.86933178, val_CC_maskV_-1.0=0.4043636, val_MSE_maskV_-1.0=0.8663013, learning_rate=0.001\n", + "Epoch 199/324 - loss=0.83342284, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41332507, MSE_maskV_-1.0=0.83325011, val_loss=0.864663, val_CC_maskV_-1.0=0.41100895, val_MSE_maskV_-1.0=0.86085445, learning_rate=0.001\n", + "Epoch 232/324 - loss=0.82881486, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41881505, MSE_maskV_-1.0=0.82884252, val_loss=0.8588385, val_CC_maskV_-1.0=0.41699678, val_MSE_maskV_-1.0=0.85549194, learning_rate=0.001\n", + "Epoch 265/324 - loss=0.82505518, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42266649, MSE_maskV_-1.0=0.82499719, val_loss=0.85775608, val_CC_maskV_-1.0=0.4167169, val_MSE_maskV_-1.0=0.85446107, learning_rate=0.001\n", + "Epoch 298/324 - loss=0.82135069, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42702678, MSE_maskV_-1.0=0.8206448, val_loss=0.85388899, val_CC_maskV_-1.0=0.42197329, val_MSE_maskV_-1.0=0.85050005, learning_rate=0.001\n", + "Epoch 324/324 - loss=0.81937093, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42889696, MSE_maskV_-1.0=0.8188175, val_loss=0.85215729, val_CC_maskV_-1.0=0.42368087, val_MSE_maskV_-1.0=0.84890765, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:50:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 78.27s\n", + "\u001b[32m2025-05-30 11:50:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:52:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 308 (stopped at 323 epochs).\n", + "\u001b[32m2025-05-30 11:52:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/324 - loss=1.6206814, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.018300688, MSE_maskV_-1.0=1.6192226, val_loss=1.0501927, val_CC_maskV_-1.0=0.10512725, val_MSE_maskV_-1.0=1.0473464, learning_rate=0.001\n", + "Epoch 34/324 - loss=0.8982262, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.32688552, MSE_maskV_-1.0=0.89752382, val_loss=0.9235447, val_CC_maskV_-1.0=0.33381751, val_MSE_maskV_-1.0=0.9202764, learning_rate=0.001\n", + "Epoch 67/324 - loss=0.87152034, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36695838, MSE_maskV_-1.0=0.87113804, val_loss=0.89891624, val_CC_maskV_-1.0=0.37033263, val_MSE_maskV_-1.0=0.89526385, learning_rate=0.001\n", + "Epoch 100/324 - loss=0.8565591, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.385463, MSE_maskV_-1.0=0.85680395, val_loss=0.88395053, val_CC_maskV_-1.0=0.38833424, val_MSE_maskV_-1.0=0.88064694, learning_rate=0.001\n", + "Epoch 133/324 - loss=0.8467446, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39757958, MSE_maskV_-1.0=0.84651792, val_loss=0.87487763, val_CC_maskV_-1.0=0.39879516, val_MSE_maskV_-1.0=0.87141496, learning_rate=0.001\n", + "Epoch 166/324 - loss=0.83910161, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4072544, MSE_maskV_-1.0=0.8395927, val_loss=0.86830872, val_CC_maskV_-1.0=0.40576994, val_MSE_maskV_-1.0=0.8652249, learning_rate=0.001\n", + "Epoch 199/324 - loss=0.83307934, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41383782, MSE_maskV_-1.0=0.83291054, val_loss=0.86367929, val_CC_maskV_-1.0=0.41235983, val_MSE_maskV_-1.0=0.85982305, learning_rate=0.001\n", + "Epoch 232/324 - loss=0.82846129, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41928908, MSE_maskV_-1.0=0.82849389, val_loss=0.8579458, val_CC_maskV_-1.0=0.418172, val_MSE_maskV_-1.0=0.85456574, learning_rate=0.001\n", + "Epoch 265/324 - loss=0.82470793, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42311975, MSE_maskV_-1.0=0.82465553, val_loss=0.8568902, val_CC_maskV_-1.0=0.41778708, val_MSE_maskV_-1.0=0.85357141, learning_rate=0.001\n", + "Epoch 298/324 - loss=0.82101274, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42745134, MSE_maskV_-1.0=0.82030982, val_loss=0.85306966, val_CC_maskV_-1.0=0.42301604, val_MSE_maskV_-1.0=0.84965217, learning_rate=0.001\n", + "Epoch 324/324 - loss=0.81904954, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42931432, MSE_maskV_-1.0=0.81849509, val_loss=0.85134, val_CC_maskV_-1.0=0.42467949, val_MSE_maskV_-1.0=0.84806913, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:52:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 77.79s\n", + "\u001b[32m2025-05-30 11:52:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.85000551)\n", + "\u001b[32m2025-05-30 11:52:15\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 762us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:52:15\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.819, R2_maskV_-1.0=0.18, CC_maskV_-1.0=0.428\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 745us/step\n", + "51/51 [==============================] - 0s 827us/step\n", + "84/84 [==============================] - 0s 725us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:52:16\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_K1HL64U_ErSV16\" (3/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_K1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:52:16\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_Cz1HL64U_ErSV16\" (4/16)\n", + "\u001b[32m2025-05-30 11:52:16\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_Cz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:52:16\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:52:16\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:52:16\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:52:16\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:52:16\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:52:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:52:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 130 (stopped at 145 epochs).\n", + "\u001b[32m2025-05-30 11:52:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/146 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0018128, rnn_1step_R2_maskV_-1.0=-0.013123691, rnn_1step_CC_maskV_-1.0=0.075921334, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91706651, val_rnn_1step_R2_maskV_-1.0=-0.059123635, val_rnn_1step_CC_maskV_-1.0=0.226927, learning_rate=0.001\n", + "Epoch 16/146 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.69706911, rnn_1step_R2_maskV_-1.0=0.29000956, rnn_1step_CC_maskV_-1.0=0.55111855, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.67708272, val_rnn_1step_R2_maskV_-1.0=0.21338919, val_rnn_1step_CC_maskV_-1.0=0.52029234, learning_rate=0.001\n", + "Epoch 31/146 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.54957873, rnn_1step_R2_maskV_-1.0=0.43742678, rnn_1step_CC_maskV_-1.0=0.67139453, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61086392, val_rnn_1step_R2_maskV_-1.0=0.29174876, val_rnn_1step_CC_maskV_-1.0=0.59363055, learning_rate=0.001\n", + "Epoch 46/146 - loss=rnn_1step_loss=0.48428226, rnn_1step_R2_maskV_-1.0=0.50324452, rnn_1step_CC_maskV_-1.0=0.71792006, rnn_1step_MSE_maskV_-1.0=0.48428228, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59499192, val_rnn_1step_R2_maskV_-1.0=0.30916142, val_rnn_1step_CC_maskV_-1.0=0.61878181, learning_rate=0.001\n", + "Epoch 61/146 - loss=rnn_1step_loss=0.43889627, rnn_1step_R2_maskV_-1.0=0.54946899, rnn_1step_CC_maskV_-1.0=0.74890602, rnn_1step_MSE_maskV_-1.0=0.43889624, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58504695, val_rnn_1step_R2_maskV_-1.0=0.31917602, val_rnn_1step_CC_maskV_-1.0=0.63579196, learning_rate=0.001\n", + "Epoch 76/146 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41394708, rnn_1step_R2_maskV_-1.0=0.57468653, rnn_1step_CC_maskV_-1.0=0.76548213, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56653285, val_rnn_1step_R2_maskV_-1.0=0.34089917, val_rnn_1step_CC_maskV_-1.0=0.65163171, learning_rate=0.001\n", + "Epoch 91/146 - loss=rnn_1step_loss=0.39594468, rnn_1step_R2_maskV_-1.0=0.59290791, rnn_1step_CC_maskV_-1.0=0.77713555, rnn_1step_MSE_maskV_-1.0=0.39594465, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55017179, val_rnn_1step_R2_maskV_-1.0=0.36047649, val_rnn_1step_CC_maskV_-1.0=0.66401768, learning_rate=0.001\n", + "Epoch 106/146 - loss=rnn_1step_loss=0.37349781, rnn_1step_R2_maskV_-1.0=0.61580569, rnn_1step_CC_maskV_-1.0=0.79131156, rnn_1step_MSE_maskV_-1.0=0.37349778, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52946764, val_rnn_1step_R2_maskV_-1.0=0.38536203, val_rnn_1step_CC_maskV_-1.0=0.68036443, learning_rate=0.001\n", + "Epoch 121/146 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35620546, rnn_1step_R2_maskV_-1.0=0.63323933, rnn_1step_CC_maskV_-1.0=0.80208081, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51699013, val_rnn_1step_R2_maskV_-1.0=0.40012217, val_rnn_1step_CC_maskV_-1.0=0.69300246, learning_rate=0.001\n", + "Epoch 136/146 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34751895, rnn_1step_R2_maskV_-1.0=0.64191175, rnn_1step_CC_maskV_-1.0=0.80748498, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51642638, val_rnn_1step_R2_maskV_-1.0=0.40060335, val_rnn_1step_CC_maskV_-1.0=0.69713712, learning_rate=0.001\n", + "Epoch 146/146 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34341201, rnn_1step_R2_maskV_-1.0=0.64602053, rnn_1step_CC_maskV_-1.0=0.8100177, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51690292, val_rnn_1step_R2_maskV_-1.0=0.39991787, val_rnn_1step_CC_maskV_-1.0=0.69821733, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:52:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.93s\n", + "\u001b[32m2025-05-30 11:52:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:52:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 246 (stopped at 261 epochs).\n", + "\u001b[32m2025-05-30 11:52:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/262 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0018353, rnn_1_1step_R2_maskV_-1.0=-0.013131056, rnn_1_1step_CC_maskV_-1.0=0.076984145, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.9162814, val_rnn_1_1step_R2_maskV_-1.0=-0.058263004, val_rnn_1_1step_CC_maskV_-1.0=0.26556647, learning_rate=0.001\n", + "Epoch 28/262 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.58868772, rnn_1_1step_R2_maskV_-1.0=0.39824349, rnn_1_1step_CC_maskV_-1.0=0.64153254, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64323282, val_rnn_1_1step_R2_maskV_-1.0=0.25380975, val_rnn_1_1step_CC_maskV_-1.0=0.55882746, learning_rate=0.001\n", + "Epoch 55/262 - loss=rnn_1_1step_loss=0.46193612, rnn_1_1step_R2_maskV_-1.0=0.52652431, rnn_1_1step_CC_maskV_-1.0=0.73374587, rnn_1_1step_MSE_maskV_-1.0=0.46193615, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58661956, val_rnn_1_1step_R2_maskV_-1.0=0.31796014, val_rnn_1_1step_CC_maskV_-1.0=0.62592572, learning_rate=0.001\n", + "Epoch 82/262 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41186795, rnn_1_1step_R2_maskV_-1.0=0.57632667, rnn_1_1step_CC_maskV_-1.0=0.76695108, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56191909, val_rnn_1_1step_R2_maskV_-1.0=0.34675777, val_rnn_1_1step_CC_maskV_-1.0=0.65170771, learning_rate=0.001\n", + "Epoch 109/262 - loss=rnn_1_1step_loss=0.3955287, rnn_1_1step_R2_maskV_-1.0=0.59287548, rnn_1_1step_CC_maskV_-1.0=0.77738428, rnn_1_1step_MSE_maskV_-1.0=0.39552873, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5488463, val_rnn_1_1step_R2_maskV_-1.0=0.36247832, val_rnn_1_1step_CC_maskV_-1.0=0.66193163, learning_rate=0.001\n", + "Epoch 136/262 - loss=rnn_1_1step_loss=0.3788034, rnn_1_1step_R2_maskV_-1.0=0.6101743, rnn_1_1step_CC_maskV_-1.0=0.78792614, rnn_1_1step_MSE_maskV_-1.0=0.37880343, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5334304, val_rnn_1_1step_R2_maskV_-1.0=0.38116586, val_rnn_1_1step_CC_maskV_-1.0=0.67321569, learning_rate=0.001\n", + "Epoch 163/262 - loss=rnn_1_1step_loss=0.35758099, rnn_1_1step_R2_maskV_-1.0=0.63217205, rnn_1_1step_CC_maskV_-1.0=0.80114353, rnn_1_1step_MSE_maskV_-1.0=0.35758096, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51875782, val_rnn_1_1step_R2_maskV_-1.0=0.39879677, val_rnn_1_1step_CC_maskV_-1.0=0.68665987, learning_rate=0.001\n", + "Epoch 190/262 - loss=rnn_1_1step_loss=0.34047866, rnn_1_1step_R2_maskV_-1.0=0.6494261, rnn_1_1step_CC_maskV_-1.0=0.8116976, rnn_1_1step_MSE_maskV_-1.0=0.34047863, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51383382, val_rnn_1_1step_R2_maskV_-1.0=0.40434441, val_rnn_1_1step_CC_maskV_-1.0=0.69529235, learning_rate=0.001\n", + "Epoch 217/262 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33056843, rnn_1_1step_R2_maskV_-1.0=0.65922946, rnn_1_1step_CC_maskV_-1.0=0.81777501, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51211303, val_rnn_1_1step_R2_maskV_-1.0=0.40603542, val_rnn_1_1step_CC_maskV_-1.0=0.69955343, learning_rate=0.001\n", + "Epoch 244/262 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32402602, rnn_1_1step_R2_maskV_-1.0=0.66575754, rnn_1_1step_CC_maskV_-1.0=0.82177716, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51077169, val_rnn_1_1step_R2_maskV_-1.0=0.40742189, val_rnn_1_1step_CC_maskV_-1.0=0.70222342, learning_rate=0.001\n", + "Epoch 262/262 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32057774, rnn_1_1step_R2_maskV_-1.0=0.66920638, rnn_1_1step_CC_maskV_-1.0=0.82385504, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51063716, val_rnn_1_1step_R2_maskV_-1.0=0.40753537, val_rnn_1_1step_CC_maskV_-1.0=0.70333141, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:52:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 26.28s\n", + "\u001b[32m2025-05-30 11:52:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.51057792)\n", + "\u001b[32m2025-05-30 11:53:01\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.294, R2_maskV_-1.0=0.706, CC_maskV_-1.0=0.841\n", + "\u001b[32m2025-05-30 11:53:01\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.477, R2_maskV_-1.0=0.459, CC_maskV_-1.0=0.728\n", + "\u001b[32m2025-05-30 11:53:01\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:53:01\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:53:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 175 (stopped at 190 epochs).\n", + "\u001b[32m2025-05-30 11:53:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/191 - loss=5.9089046, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.020977661, MSE_maskV_-1.0=5.8945999, val_loss=1.6603594, val_CC_maskV_-1.0=0.04747209, val_MSE_maskV_-1.0=1.654548, learning_rate=0.001\n", + "Epoch 21/191 - loss=0.81044918, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43536776, MSE_maskV_-1.0=0.81052023, val_loss=0.83592516, val_CC_maskV_-1.0=0.43371022, val_MSE_maskV_-1.0=0.8331337, learning_rate=0.001\n", + "Epoch 41/191 - loss=0.7648707, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48463133, MSE_maskV_-1.0=0.76932669, val_loss=0.79649764, val_CC_maskV_-1.0=0.47616151, val_MSE_maskV_-1.0=0.79395592, learning_rate=0.001\n", + "Epoch 61/191 - loss=0.74551117, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50540936, MSE_maskV_-1.0=0.74631184, val_loss=0.77746516, val_CC_maskV_-1.0=0.49491829, val_MSE_maskV_-1.0=0.77566212, learning_rate=0.001\n", + "Epoch 81/191 - loss=0.7340101, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5168587, MSE_maskV_-1.0=0.73420346, val_loss=0.76099557, val_CC_maskV_-1.0=0.51137447, val_MSE_maskV_-1.0=0.75897634, learning_rate=0.001\n", + "Epoch 101/191 - loss=0.72725201, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52272081, MSE_maskV_-1.0=0.72648019, val_loss=0.75647449, val_CC_maskV_-1.0=0.51384681, val_MSE_maskV_-1.0=0.75473893, learning_rate=0.001\n", + "Epoch 121/191 - loss=0.72286981, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52692145, MSE_maskV_-1.0=0.72284997, val_loss=0.74944407, val_CC_maskV_-1.0=0.52114952, val_MSE_maskV_-1.0=0.74752522, learning_rate=0.001\n", + "Epoch 141/191 - loss=0.72054213, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52918643, MSE_maskV_-1.0=0.71982372, val_loss=0.74884164, val_CC_maskV_-1.0=0.52016884, val_MSE_maskV_-1.0=0.74715626, learning_rate=0.001\n", + "Epoch 161/191 - loss=0.71888989, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53078043, MSE_maskV_-1.0=0.71876961, val_loss=0.74920702, val_CC_maskV_-1.0=0.5210163, val_MSE_maskV_-1.0=0.74728101, learning_rate=0.001\n", + "Epoch 181/191 - loss=0.71761465, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53197449, MSE_maskV_-1.0=0.71810395, val_loss=0.74661541, val_CC_maskV_-1.0=0.52312195, val_MSE_maskV_-1.0=0.74493229, learning_rate=0.001\n", + "Epoch 191/191 - loss=0.71710676, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53180498, MSE_maskV_-1.0=0.71729988, val_loss=0.74504805, val_CC_maskV_-1.0=0.52409315, val_MSE_maskV_-1.0=0.74329543, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:53:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 47.08s\n", + "\u001b[32m2025-05-30 11:53:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:54:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 175 (stopped at 190 epochs).\n", + "\u001b[32m2025-05-30 11:54:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/191 - loss=8.0813255, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=-0.002736124, MSE_maskV_-1.0=8.0606251, val_loss=1.9480528, val_CC_maskV_-1.0=0.014458096, val_MSE_maskV_-1.0=1.9418076, learning_rate=0.001\n", + "Epoch 21/191 - loss=0.80749297, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43861607, MSE_maskV_-1.0=0.80757141, val_loss=0.83079737, val_CC_maskV_-1.0=0.43809023, val_MSE_maskV_-1.0=0.82812482, learning_rate=0.001\n", + "Epoch 41/191 - loss=0.76239449, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48727149, MSE_maskV_-1.0=0.76681775, val_loss=0.79141641, val_CC_maskV_-1.0=0.48086801, val_MSE_maskV_-1.0=0.78908592, learning_rate=0.001\n", + "Epoch 61/191 - loss=0.7439931, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50695896, MSE_maskV_-1.0=0.74470162, val_loss=0.77315533, val_CC_maskV_-1.0=0.49879643, val_MSE_maskV_-1.0=0.77155155, learning_rate=0.001\n", + "Epoch 81/191 - loss=0.73297316, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5178144, MSE_maskV_-1.0=0.73315978, val_loss=0.75799382, val_CC_maskV_-1.0=0.51390475, val_MSE_maskV_-1.0=0.75609708, learning_rate=0.001\n", + "Epoch 101/191 - loss=0.72653294, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52343315, MSE_maskV_-1.0=0.72576118, val_loss=0.75426477, val_CC_maskV_-1.0=0.51578957, val_MSE_maskV_-1.0=0.75262499, learning_rate=0.001\n", + "Epoch 121/191 - loss=0.72238803, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52737319, MSE_maskV_-1.0=0.72236222, val_loss=0.74781787, val_CC_maskV_-1.0=0.52250022, val_MSE_maskV_-1.0=0.7459833, learning_rate=0.001\n", + "Epoch 141/191 - loss=0.72018725, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52950144, MSE_maskV_-1.0=0.71947944, val_loss=0.74743408, val_CC_maskV_-1.0=0.52138656, val_MSE_maskV_-1.0=0.74581116, learning_rate=0.001\n", + "Epoch 161/191 - loss=0.71861601, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5310427, MSE_maskV_-1.0=0.71850753, val_loss=0.74804002, val_CC_maskV_-1.0=0.52195984, val_MSE_maskV_-1.0=0.74618769, learning_rate=0.001\n", + "Epoch 181/191 - loss=0.71739924, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53218228, MSE_maskV_-1.0=0.71789294, val_loss=0.74575251, val_CC_maskV_-1.0=0.52381951, val_MSE_maskV_-1.0=0.74412149, learning_rate=0.001\n", + "Epoch 191/191 - loss=0.7169295, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53197747, MSE_maskV_-1.0=0.71712011, val_loss=0.74427569, val_CC_maskV_-1.0=0.52469206, val_MSE_maskV_-1.0=0.74257308, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:54:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 46.68s\n", + "\u001b[32m2025-05-30 11:54:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.74143708)\n", + "\u001b[32m2025-05-30 11:54:35\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 752us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:54:35\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.715, R2_maskV_-1.0=0.285, CC_maskV_-1.0=0.534\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 698us/step\n", + "51/51 [==============================] - 0s 744us/step\n", + "84/84 [==============================] - 0s 730us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:54:36\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_Cz1HL64U_ErSV16\" (4/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_Cz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:54:36\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_Cy1HL64U_ErSV16\" (5/16)\n", + "\u001b[32m2025-05-30 11:54:36\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_Cy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:54:36\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:54:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:54:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:54:36\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:54:36\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:54:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:54:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 160 (stopped at 175 epochs).\n", + "\u001b[32m2025-05-30 11:54:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/176 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0043197, rnn_1step_R2_maskV_-1.0=-0.015764125, rnn_1step_CC_maskV_-1.0=-0.032760162, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91793513, val_rnn_1step_R2_maskV_-1.0=-0.060361251, val_rnn_1step_CC_maskV_-1.0=0.049544148, learning_rate=0.001\n", + "Epoch 19/176 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.69299048, rnn_1step_R2_maskV_-1.0=0.29520974, rnn_1step_CC_maskV_-1.0=0.55305803, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.68959635, val_rnn_1step_R2_maskV_-1.0=0.19910601, val_rnn_1step_CC_maskV_-1.0=0.50318253, learning_rate=0.001\n", + "Epoch 37/176 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.55592287, rnn_1step_R2_maskV_-1.0=0.43208739, rnn_1step_CC_maskV_-1.0=0.66576815, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63898319, val_rnn_1step_R2_maskV_-1.0=0.25916398, val_rnn_1step_CC_maskV_-1.0=0.57751101, learning_rate=0.001\n", + "Epoch 55/176 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.50453281, rnn_1step_R2_maskV_-1.0=0.48436722, rnn_1step_CC_maskV_-1.0=0.70378721, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61250877, val_rnn_1step_R2_maskV_-1.0=0.28783667, val_rnn_1step_CC_maskV_-1.0=0.60713351, learning_rate=0.001\n", + "Epoch 73/176 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.48561895, rnn_1step_R2_maskV_-1.0=0.50437099, rnn_1step_CC_maskV_-1.0=0.71702266, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60064703, val_rnn_1step_R2_maskV_-1.0=0.30123836, val_rnn_1step_CC_maskV_-1.0=0.61607486, learning_rate=0.001\n", + "Epoch 91/176 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.46281409, rnn_1step_R2_maskV_-1.0=0.52800143, rnn_1step_CC_maskV_-1.0=0.73270631, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57914931, val_rnn_1step_R2_maskV_-1.0=0.32695335, val_rnn_1step_CC_maskV_-1.0=0.63440347, learning_rate=0.001\n", + "Epoch 109/176 - loss=rnn_1step_loss=0.43943653, rnn_1step_R2_maskV_-1.0=0.55139852, rnn_1step_CC_maskV_-1.0=0.74832964, rnn_1step_MSE_maskV_-1.0=0.4394365, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55562681, val_rnn_1step_R2_maskV_-1.0=0.35492247, val_rnn_1step_CC_maskV_-1.0=0.65559745, learning_rate=0.001\n", + "Epoch 127/176 - loss=rnn_1step_loss=0.42854705, rnn_1step_R2_maskV_-1.0=0.56213748, rnn_1step_CC_maskV_-1.0=0.75563216, rnn_1step_MSE_maskV_-1.0=0.42854711, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54963261, val_rnn_1step_R2_maskV_-1.0=0.36163017, val_rnn_1step_CC_maskV_-1.0=0.6627506, learning_rate=0.001\n", + "Epoch 145/176 - loss=rnn_1step_loss=0.421736, rnn_1step_R2_maskV_-1.0=0.5687747, rnn_1step_CC_maskV_-1.0=0.76013875, rnn_1step_MSE_maskV_-1.0=0.42173603, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54758114, val_rnn_1step_R2_maskV_-1.0=0.36370701, val_rnn_1step_CC_maskV_-1.0=0.66640526, learning_rate=0.001\n", + "Epoch 163/176 - loss=rnn_1step_loss=0.41779184, rnn_1step_R2_maskV_-1.0=0.5725494, rnn_1step_CC_maskV_-1.0=0.76272219, rnn_1step_MSE_maskV_-1.0=0.41779181, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54720157, val_rnn_1step_R2_maskV_-1.0=0.36396468, val_rnn_1step_CC_maskV_-1.0=0.66836697, learning_rate=0.001\n", + "Epoch 176/176 - loss=rnn_1step_loss=0.41610524, rnn_1step_R2_maskV_-1.0=0.57412314, rnn_1step_CC_maskV_-1.0=0.76382565, rnn_1step_MSE_maskV_-1.0=0.41610521, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5474562, val_rnn_1step_R2_maskV_-1.0=0.36360192, val_rnn_1step_CC_maskV_-1.0=0.66909957, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:54:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 16.69s\n", + "\u001b[32m2025-05-30 11:54:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:55:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 154 (stopped at 169 epochs).\n", + "\u001b[32m2025-05-30 11:55:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/170 - loss=rnn_1_1step_loss=0.9987486, rnn_1_1step_R2_maskV_-1.0=-0.010147627, rnn_1_1step_CC_maskV_-1.0=0.091195166, rnn_1_1step_MSE_maskV_-1.0=0.99874872, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91175336, val_rnn_1_1step_R2_maskV_-1.0=-0.052831307, val_rnn_1_1step_CC_maskV_-1.0=0.17907766, learning_rate=0.001\n", + "Epoch 18/170 - loss=rnn_1_1step_loss=0.72811651, rnn_1_1step_R2_maskV_-1.0=0.25924444, rnn_1_1step_CC_maskV_-1.0=0.52387971, rnn_1_1step_MSE_maskV_-1.0=0.72811657, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.69672298, val_rnn_1_1step_R2_maskV_-1.0=0.1920882, val_rnn_1_1step_CC_maskV_-1.0=0.49399433, learning_rate=0.001\n", + "Epoch 35/170 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.55071133, rnn_1_1step_R2_maskV_-1.0=0.43727392, rnn_1_1step_CC_maskV_-1.0=0.66971529, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61501116, val_rnn_1_1step_R2_maskV_-1.0=0.28611737, val_rnn_1_1step_CC_maskV_-1.0=0.59565145, learning_rate=0.001\n", + "Epoch 52/170 - loss=rnn_1_1step_loss=0.50473362, rnn_1_1step_R2_maskV_-1.0=0.48469484, rnn_1_1step_CC_maskV_-1.0=0.70374638, rnn_1_1step_MSE_maskV_-1.0=0.50473356, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60681581, val_rnn_1_1step_R2_maskV_-1.0=0.29439437, val_rnn_1_1step_CC_maskV_-1.0=0.61068642, learning_rate=0.001\n", + "Epoch 69/170 - loss=rnn_1_1step_loss=0.47971389, rnn_1_1step_R2_maskV_-1.0=0.51034153, rnn_1_1step_CC_maskV_-1.0=0.72124624, rnn_1_1step_MSE_maskV_-1.0=0.47971392, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59244472, val_rnn_1_1step_R2_maskV_-1.0=0.31099623, val_rnn_1_1step_CC_maskV_-1.0=0.62369847, learning_rate=0.001\n", + "Epoch 86/170 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.45059672, rnn_1_1step_R2_maskV_-1.0=0.53995907, rnn_1_1step_CC_maskV_-1.0=0.74103856, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56633681, val_rnn_1_1step_R2_maskV_-1.0=0.34230471, val_rnn_1_1step_CC_maskV_-1.0=0.64603102, learning_rate=0.001\n", + "Epoch 103/170 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.43536934, rnn_1_1step_R2_maskV_-1.0=0.55521107, rnn_1_1step_CC_maskV_-1.0=0.75119483, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55528492, val_rnn_1_1step_R2_maskV_-1.0=0.35526139, val_rnn_1_1step_CC_maskV_-1.0=0.65747356, learning_rate=0.001\n", + "Epoch 120/170 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42803642, rnn_1_1step_R2_maskV_-1.0=0.56238925, rnn_1_1step_CC_maskV_-1.0=0.75607008, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55292863, val_rnn_1_1step_R2_maskV_-1.0=0.35770711, val_rnn_1_1step_CC_maskV_-1.0=0.66186148, learning_rate=0.001\n", + "Epoch 137/170 - loss=rnn_1_1step_loss=0.42337099, rnn_1_1step_R2_maskV_-1.0=0.56688839, rnn_1_1step_CC_maskV_-1.0=0.75914049, rnn_1_1step_MSE_maskV_-1.0=0.42337102, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55177689, val_rnn_1_1step_R2_maskV_-1.0=0.35883749, val_rnn_1_1step_CC_maskV_-1.0=0.66478896, learning_rate=0.001\n", + "Epoch 154/170 - loss=rnn_1_1step_loss=0.4204832, rnn_1_1step_R2_maskV_-1.0=0.56963468, rnn_1_1step_CC_maskV_-1.0=0.76103628, rnn_1_1step_MSE_maskV_-1.0=0.42048323, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5515663, val_rnn_1_1step_R2_maskV_-1.0=0.35896397, val_rnn_1_1step_CC_maskV_-1.0=0.66647565, learning_rate=0.001\n", + "Epoch 170/170 - loss=rnn_1_1step_loss=0.41867939, rnn_1_1step_R2_maskV_-1.0=0.57133627, rnn_1_1step_CC_maskV_-1.0=0.76222181, rnn_1_1step_MSE_maskV_-1.0=0.41867936, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55157596, val_rnn_1_1step_R2_maskV_-1.0=0.35889897, val_rnn_1_1step_CC_maskV_-1.0=0.66747564, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:55:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 16.27s\n", + "\u001b[32m2025-05-30 11:55:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.54718643)\n", + "\u001b[32m2025-05-30 11:55:10\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.371, R2_maskV_-1.0=0.629, CC_maskV_-1.0=0.793\n", + "\u001b[32m2025-05-30 11:55:11\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.506, R2_maskV_-1.0=0.425, CC_maskV_-1.0=0.699\n", + "\u001b[32m2025-05-30 11:55:11\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:55:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:55:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 157 (stopped at 172 epochs).\n", + "\u001b[32m2025-05-30 11:55:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/173 - loss=1.6605082, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.086010605, MSE_maskV_-1.0=1.6587124, val_loss=1.0430937, val_CC_maskV_-1.0=0.16797061, val_MSE_maskV_-1.0=1.0403752, learning_rate=0.001\n", + "Epoch 19/173 - loss=0.75138146, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49881768, MSE_maskV_-1.0=0.75075519, val_loss=0.78211856, val_CC_maskV_-1.0=0.48311523, val_MSE_maskV_-1.0=0.78020334, learning_rate=0.001\n", + "Epoch 37/173 - loss=0.69414699, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55210936, MSE_maskV_-1.0=0.6940788, val_loss=0.7250911, val_CC_maskV_-1.0=0.53710192, val_MSE_maskV_-1.0=0.72299623, learning_rate=0.001\n", + "Epoch 55/173 - loss=0.67402899, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56968284, MSE_maskV_-1.0=0.67373776, val_loss=0.71418869, val_CC_maskV_-1.0=0.54738969, val_MSE_maskV_-1.0=0.7115106, learning_rate=0.001\n", + "Epoch 73/173 - loss=0.6617803, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57929057, MSE_maskV_-1.0=0.66212958, val_loss=0.70747793, val_CC_maskV_-1.0=0.55353719, val_MSE_maskV_-1.0=0.7050308, learning_rate=0.001\n", + "Epoch 91/173 - loss=0.65231556, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58787125, MSE_maskV_-1.0=0.65275985, val_loss=0.69897527, val_CC_maskV_-1.0=0.55886406, val_MSE_maskV_-1.0=0.69650298, learning_rate=0.001\n", + "Epoch 109/173 - loss=0.64515609, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59297258, MSE_maskV_-1.0=0.64512551, val_loss=0.69573212, val_CC_maskV_-1.0=0.56281638, val_MSE_maskV_-1.0=0.69298875, learning_rate=0.001\n", + "Epoch 127/173 - loss=0.6418407, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59646589, MSE_maskV_-1.0=0.64203656, val_loss=0.69076401, val_CC_maskV_-1.0=0.56645977, val_MSE_maskV_-1.0=0.68825793, learning_rate=0.001\n", + "Epoch 145/173 - loss=0.63761216, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59899521, MSE_maskV_-1.0=0.63719034, val_loss=0.68695128, val_CC_maskV_-1.0=0.56976098, val_MSE_maskV_-1.0=0.68450052, learning_rate=0.001\n", + "Epoch 163/173 - loss=0.63319695, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60315388, MSE_maskV_-1.0=0.63326603, val_loss=0.68814701, val_CC_maskV_-1.0=0.56881875, val_MSE_maskV_-1.0=0.68606204, learning_rate=0.001\n", + "Epoch 173/173 - loss=0.63080996, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6052168, MSE_maskV_-1.0=0.63084817, val_loss=0.68562269, val_CC_maskV_-1.0=0.57184023, val_MSE_maskV_-1.0=0.68272054, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:55:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 44.27s\n", + "\u001b[32m2025-05-30 11:55:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:57:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 240 (stopped at 255 epochs).\n", + "\u001b[32m2025-05-30 11:57:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/256 - loss=1.8313076, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.046507876, MSE_maskV_-1.0=1.8292946, val_loss=1.0824426, val_CC_maskV_-1.0=0.1002058, val_MSE_maskV_-1.0=1.0836257, learning_rate=0.001\n", + "Epoch 27/256 - loss=0.72067112, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52692312, MSE_maskV_-1.0=0.71985197, val_loss=0.75116497, val_CC_maskV_-1.0=0.51591468, val_MSE_maskV_-1.0=0.74930316, learning_rate=0.001\n", + "Epoch 53/256 - loss=0.67921382, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56565654, MSE_maskV_-1.0=0.67910957, val_loss=0.71511692, val_CC_maskV_-1.0=0.54621679, val_MSE_maskV_-1.0=0.71342814, learning_rate=0.001\n", + "Epoch 79/256 - loss=0.66181529, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58007663, MSE_maskV_-1.0=0.6616233, val_loss=0.7033239, val_CC_maskV_-1.0=0.5578261, val_MSE_maskV_-1.0=0.70203078, learning_rate=0.001\n", + "Epoch 105/256 - loss=0.65222698, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58936232, MSE_maskV_-1.0=0.6525057, val_loss=0.70148575, val_CC_maskV_-1.0=0.55865395, val_MSE_maskV_-1.0=0.69997102, learning_rate=0.001\n", + "Epoch 131/256 - loss=0.64348423, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59495717, MSE_maskV_-1.0=0.643457, val_loss=0.69992042, val_CC_maskV_-1.0=0.56019658, val_MSE_maskV_-1.0=0.6977492, learning_rate=0.001\n", + "Epoch 157/256 - loss=0.63873333, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59889477, MSE_maskV_-1.0=0.63862556, val_loss=0.68728983, val_CC_maskV_-1.0=0.56968355, val_MSE_maskV_-1.0=0.6851182, learning_rate=0.001\n", + "Epoch 183/256 - loss=0.6340903, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60285604, MSE_maskV_-1.0=0.63415134, val_loss=0.68126535, val_CC_maskV_-1.0=0.57478255, val_MSE_maskV_-1.0=0.67875761, learning_rate=0.001\n", + "Epoch 209/256 - loss=0.63051087, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60477066, MSE_maskV_-1.0=0.63001817, val_loss=0.6836049, val_CC_maskV_-1.0=0.5723235, val_MSE_maskV_-1.0=0.68140829, learning_rate=0.001\n", + "Epoch 235/256 - loss=0.62707204, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60811198, MSE_maskV_-1.0=0.6270932, val_loss=0.67745423, val_CC_maskV_-1.0=0.57805932, val_MSE_maskV_-1.0=0.67553663, learning_rate=0.001\n", + "Epoch 256/256 - loss=0.62621748, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6081475, MSE_maskV_-1.0=0.62668991, val_loss=0.67502028, val_CC_maskV_-1.0=0.58096939, val_MSE_maskV_-1.0=0.67273009, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:57:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 65.54s\n", + "\u001b[32m2025-05-30 11:57:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.6717878)\n", + "\u001b[32m2025-05-30 11:57:00\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 817us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:57:01\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.619, R2_maskV_-1.0=0.384, CC_maskV_-1.0=0.617\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 754us/step\n", + "51/51 [==============================] - 0s 728us/step\n", + "84/84 [==============================] - 0s 732us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 11:57:02\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_Cy1HL64U_ErSV16\" (5/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_Cy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 11:57:02\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_uAK1HL64U_ErSV16\" (6/16)\n", + "\u001b[32m2025-05-30 11:57:02\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAK1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 11:57:02\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 11:57:02\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 11:57:02\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 11:57:02\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 11:57:02\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 11:57:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:57:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 82 (stopped at 97 epochs).\n", + "\u001b[32m2025-05-30 11:57:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/98 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.001523, rnn_1step_R2_maskV_-1.0=-0.012841199, rnn_1step_CC_maskV_-1.0=0.10531867, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91621476, val_rnn_1step_R2_maskV_-1.0=-0.058129609, val_rnn_1step_CC_maskV_-1.0=0.29509011, learning_rate=0.001\n", + "Epoch 11/98 - loss=rnn_1step_loss=0.82064515, rnn_1step_R2_maskV_-1.0=0.16943854, rnn_1step_CC_maskV_-1.0=0.43521792, rnn_1step_MSE_maskV_-1.0=0.82064521, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.74705011, val_rnn_1step_R2_maskV_-1.0=0.13579643, val_rnn_1step_CC_maskV_-1.0=0.43884626, learning_rate=0.001\n", + "Epoch 21/98 - loss=rnn_1step_loss=0.63003772, rnn_1step_R2_maskV_-1.0=0.3552466, rnn_1step_CC_maskV_-1.0=0.60852575, rnn_1step_MSE_maskV_-1.0=0.63003778, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64837664, val_rnn_1step_R2_maskV_-1.0=0.24921624, val_rnn_1step_CC_maskV_-1.0=0.54810095, learning_rate=0.001\n", + "Epoch 31/98 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.53549868, rnn_1step_R2_maskV_-1.0=0.45037627, rnn_1step_CC_maskV_-1.0=0.6821034, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61949897, val_rnn_1step_R2_maskV_-1.0=0.28184187, val_rnn_1step_CC_maskV_-1.0=0.57828116, learning_rate=0.001\n", + "Epoch 41/98 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.44649342, rnn_1step_R2_maskV_-1.0=0.54021323, rnn_1step_CC_maskV_-1.0=0.7439841, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58124703, val_rnn_1step_R2_maskV_-1.0=0.32622159, val_rnn_1step_CC_maskV_-1.0=0.62191164, learning_rate=0.001\n", + "Epoch 51/98 - loss=rnn_1step_loss=0.37056243, rnn_1step_R2_maskV_-1.0=0.61771238, rnn_1step_CC_maskV_-1.0=0.79342389, rnn_1step_MSE_maskV_-1.0=0.3705624, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55257595, val_rnn_1step_R2_maskV_-1.0=0.35868138, val_rnn_1step_CC_maskV_-1.0=0.65810329, learning_rate=0.001\n", + "Epoch 61/98 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32249734, rnn_1step_R2_maskV_-1.0=0.66742361, rnn_1step_CC_maskV_-1.0=0.82327139, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52571261, val_rnn_1step_R2_maskV_-1.0=0.3897934, val_rnn_1step_CC_maskV_-1.0=0.68003452, learning_rate=0.001\n", + "Epoch 71/98 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.28740758, rnn_1step_R2_maskV_-1.0=0.70347261, rnn_1step_CC_maskV_-1.0=0.8442449, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52153128, val_rnn_1step_R2_maskV_-1.0=0.39529616, val_rnn_1step_CC_maskV_-1.0=0.68744695, learning_rate=0.001\n", + "Epoch 81/98 - loss=rnn_1step_loss=0.25556716, rnn_1step_R2_maskV_-1.0=0.73622286, rnn_1step_CC_maskV_-1.0=0.86319143, rnn_1step_MSE_maskV_-1.0=0.25556713, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49706015, val_rnn_1step_R2_maskV_-1.0=0.42432642, val_rnn_1step_CC_maskV_-1.0=0.70502079, learning_rate=0.001\n", + "Epoch 91/98 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.23710018, rnn_1step_R2_maskV_-1.0=0.75507659, rnn_1step_CC_maskV_-1.0=0.87356061, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49824056, val_rnn_1step_R2_maskV_-1.0=0.42376021, val_rnn_1step_CC_maskV_-1.0=0.70819068, learning_rate=0.001\n", + "Epoch 98/98 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.22217472, rnn_1step_R2_maskV_-1.0=0.77058965, rnn_1step_CC_maskV_-1.0=0.88202447, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49654827, val_rnn_1step_R2_maskV_-1.0=0.42546108, val_rnn_1step_CC_maskV_-1.0=0.71057302, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:57:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.49s\n", + "\u001b[32m2025-05-30 11:57:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 11:57:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 36 (stopped at 51 epochs).\n", + "\u001b[32m2025-05-30 11:57:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/52 - loss=rnn_1_1step_loss=1.002103, rnn_1_1step_R2_maskV_-1.0=-0.013428636, rnn_1_1step_CC_maskV_-1.0=0.054403901, rnn_1_1step_MSE_maskV_-1.0=1.0021031, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91720515, val_rnn_1_1step_R2_maskV_-1.0=-0.059330523, val_rnn_1_1step_CC_maskV_-1.0=0.1684923, learning_rate=0.001\n", + "Epoch 7/52 - loss=rnn_1_1step_loss=0.96230799, rnn_1_1step_R2_maskV_-1.0=0.026802622, rnn_1_1step_CC_maskV_-1.0=0.41626063, rnn_1_1step_MSE_maskV_-1.0=0.96230805, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.87265277, val_rnn_1_1step_R2_maskV_-1.0=-0.0082081705, val_rnn_1_1step_CC_maskV_-1.0=0.36375821, learning_rate=0.001\n", + "Epoch 13/52 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.75992805, rnn_1_1step_R2_maskV_-1.0=0.22675391, rnn_1_1step_CC_maskV_-1.0=0.49741855, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.70217729, val_rnn_1_1step_R2_maskV_-1.0=0.18624948, val_rnn_1_1step_CC_maskV_-1.0=0.4746328, learning_rate=0.001\n", + "Epoch 19/52 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.61518902, rnn_1_1step_R2_maskV_-1.0=0.37038082, rnn_1_1step_CC_maskV_-1.0=0.62251651, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62833357, val_rnn_1_1step_R2_maskV_-1.0=0.27135083, val_rnn_1_1step_CC_maskV_-1.0=0.55840236, learning_rate=0.001\n", + "Epoch 25/52 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.52989727, rnn_1_1step_R2_maskV_-1.0=0.45644516, rnn_1_1step_CC_maskV_-1.0=0.68555617, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59050059, val_rnn_1_1step_R2_maskV_-1.0=0.31411502, val_rnn_1_1step_CC_maskV_-1.0=0.604563, learning_rate=0.001\n", + "Epoch 31/52 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.47002104, rnn_1_1step_R2_maskV_-1.0=0.51609349, rnn_1_1step_CC_maskV_-1.0=0.72756875, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56798863, val_rnn_1_1step_R2_maskV_-1.0=0.34085557, val_rnn_1_1step_CC_maskV_-1.0=0.63159651, learning_rate=0.001\n", + "Epoch 37/52 - loss=rnn_1_1step_loss=0.41590145, rnn_1_1step_R2_maskV_-1.0=0.57067144, rnn_1_1step_CC_maskV_-1.0=0.76388544, rnn_1_1step_MSE_maskV_-1.0=0.41590148, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55871886, val_rnn_1_1step_R2_maskV_-1.0=0.35179627, val_rnn_1_1step_CC_maskV_-1.0=0.64882368, learning_rate=0.001\n", + "Epoch 43/52 - loss=rnn_1_1step_loss=0.37428573, rnn_1_1step_R2_maskV_-1.0=0.61287069, rnn_1_1step_CC_maskV_-1.0=0.79084188, rnn_1_1step_MSE_maskV_-1.0=0.3742857, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56624609, val_rnn_1_1step_R2_maskV_-1.0=0.34297103, val_rnn_1_1step_CC_maskV_-1.0=0.65131915, learning_rate=0.001\n", + "Epoch 49/52 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.34393227, rnn_1_1step_R2_maskV_-1.0=0.64424491, rnn_1_1step_CC_maskV_-1.0=0.80999315, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56263977, val_rnn_1_1step_R2_maskV_-1.0=0.34691107, val_rnn_1_1step_CC_maskV_-1.0=0.65804076, learning_rate=0.001\n", + "Epoch 52/52 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33120614, rnn_1_1step_R2_maskV_-1.0=0.65748358, rnn_1_1step_CC_maskV_-1.0=0.81793451, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56278712, val_rnn_1_1step_R2_maskV_-1.0=0.34670442, val_rnn_1_1step_CC_maskV_-1.0=0.66048503, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:57:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 8.10s\n", + "\u001b[32m2025-05-30 11:57:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.48563138)\n", + "\u001b[32m2025-05-30 11:57:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.237, R2_maskV_-1.0=0.763, CC_maskV_-1.0=0.874\n", + "\u001b[32m2025-05-30 11:57:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.45, R2_maskV_-1.0=0.492, CC_maskV_-1.0=0.738\n", + "\u001b[32m2025-05-30 11:57:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 11:57:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 11:59:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 430 (stopped at 445 epochs).\n", + "\u001b[32m2025-05-30 11:59:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/446 - loss=1.3311095, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.063296132, MSE_maskV_-1.0=1.3305762, val_loss=1.0359511, val_CC_maskV_-1.0=0.14372003, val_MSE_maskV_-1.0=1.0335566, learning_rate=0.001\n", + "Epoch 46/446 - loss=0.87533194, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35848153, MSE_maskV_-1.0=0.87649602, val_loss=0.90574765, val_CC_maskV_-1.0=0.34927377, val_MSE_maskV_-1.0=0.90368217, learning_rate=0.001\n", + "Epoch 91/446 - loss=0.85430545, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38638252, MSE_maskV_-1.0=0.85470897, val_loss=0.8840068, val_CC_maskV_-1.0=0.3782582, val_MSE_maskV_-1.0=0.88146788, learning_rate=0.001\n", + "Epoch 136/446 - loss=0.84370482, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39895764, MSE_maskV_-1.0=0.84451509, val_loss=0.87282938, val_CC_maskV_-1.0=0.39137602, val_MSE_maskV_-1.0=0.87014747, learning_rate=0.001\n", + "Epoch 181/446 - loss=0.83745658, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40588433, MSE_maskV_-1.0=0.83799499, val_loss=0.86730492, val_CC_maskV_-1.0=0.39726746, val_MSE_maskV_-1.0=0.8644684, learning_rate=0.001\n", + "Epoch 226/446 - loss=0.83346975, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40954322, MSE_maskV_-1.0=0.83302671, val_loss=0.86439288, val_CC_maskV_-1.0=0.39974695, val_MSE_maskV_-1.0=0.86153519, learning_rate=0.001\n", + "Epoch 271/446 - loss=0.83059293, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41268504, MSE_maskV_-1.0=0.83052248, val_loss=0.86116439, val_CC_maskV_-1.0=0.40315536, val_MSE_maskV_-1.0=0.85874969, learning_rate=0.001\n", + "Epoch 316/446 - loss=0.82864153, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41517353, MSE_maskV_-1.0=0.8286038, val_loss=0.85891312, val_CC_maskV_-1.0=0.40505469, val_MSE_maskV_-1.0=0.85673046, learning_rate=0.001\n", + "Epoch 361/446 - loss=0.82692361, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41588438, MSE_maskV_-1.0=0.8275941, val_loss=0.8565591, val_CC_maskV_-1.0=0.40667149, val_MSE_maskV_-1.0=0.85428733, learning_rate=0.001\n", + "Epoch 406/446 - loss=0.82576567, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41750494, MSE_maskV_-1.0=0.82609749, val_loss=0.85655826, val_CC_maskV_-1.0=0.40684494, val_MSE_maskV_-1.0=0.85491896, learning_rate=0.001\n", + "Epoch 446/446 - loss=0.82503963, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41903612, MSE_maskV_-1.0=0.82572001, val_loss=0.85573208, val_CC_maskV_-1.0=0.40771675, val_MSE_maskV_-1.0=0.85362107, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 11:59:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 109.09s\n", + "\u001b[32m2025-05-30 11:59:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:01:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 430 (stopped at 445 epochs).\n", + "\u001b[32m2025-05-30 12:01:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/446 - loss=1.4138162, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.05728611, MSE_maskV_-1.0=1.4130975, val_loss=1.0435179, val_CC_maskV_-1.0=0.13949713, val_MSE_maskV_-1.0=1.0388395, learning_rate=0.001\n", + "Epoch 46/446 - loss=0.87432861, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35982442, MSE_maskV_-1.0=0.87551826, val_loss=0.90474463, val_CC_maskV_-1.0=0.35124132, val_MSE_maskV_-1.0=0.90247393, learning_rate=0.001\n", + "Epoch 91/446 - loss=0.85415453, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38641798, MSE_maskV_-1.0=0.85456145, val_loss=0.88397938, val_CC_maskV_-1.0=0.37848163, val_MSE_maskV_-1.0=0.8813259, learning_rate=0.001\n", + "Epoch 136/446 - loss=0.8438279, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.398707, MSE_maskV_-1.0=0.84463048, val_loss=0.87311417, val_CC_maskV_-1.0=0.39116389, val_MSE_maskV_-1.0=0.87039018, learning_rate=0.001\n", + "Epoch 181/446 - loss=0.83763838, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4055897, MSE_maskV_-1.0=0.83817977, val_loss=0.86765361, val_CC_maskV_-1.0=0.39699507, val_MSE_maskV_-1.0=0.86480707, learning_rate=0.001\n", + "Epoch 226/446 - loss=0.83364719, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40928146, MSE_maskV_-1.0=0.83320975, val_loss=0.86476249, val_CC_maskV_-1.0=0.39949006, val_MSE_maskV_-1.0=0.86190122, learning_rate=0.001\n", + "Epoch 271/446 - loss=0.8307451, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41248262, MSE_maskV_-1.0=0.83067286, val_loss=0.8614406, val_CC_maskV_-1.0=0.40300006, val_MSE_maskV_-1.0=0.85903168, learning_rate=0.001\n", + "Epoch 316/446 - loss=0.82876045, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41503188, MSE_maskV_-1.0=0.82872564, val_loss=0.85915053, val_CC_maskV_-1.0=0.40492424, val_MSE_maskV_-1.0=0.85697222, learning_rate=0.001\n", + "Epoch 361/446 - loss=0.8270154, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41577825, MSE_maskV_-1.0=0.82768911, val_loss=0.85675806, val_CC_maskV_-1.0=0.4065834, val_MSE_maskV_-1.0=0.85449547, learning_rate=0.001\n", + "Epoch 406/446 - loss=0.8258301, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41743666, MSE_maskV_-1.0=0.82615721, val_loss=0.85672694, val_CC_maskV_-1.0=0.40677023, val_MSE_maskV_-1.0=0.85509807, learning_rate=0.001\n", + "Epoch 446/446 - loss=0.825086, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41898474, MSE_maskV_-1.0=0.82577538, val_loss=0.8558498, val_CC_maskV_-1.0=0.40769398, val_MSE_maskV_-1.0=0.8537513, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:01:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 109.49s\n", + "\u001b[32m2025-05-30 12:01:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.85454261)\n", + "\u001b[32m2025-05-30 12:01:03\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 737us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:01:03\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.824, R2_maskV_-1.0=0.176, CC_maskV_-1.0=0.42\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 786us/step\n", + "51/51 [==============================] - 0s 815us/step\n", + "84/84 [==============================] - 0s 674us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:01:04\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_uAK1HL64U_ErSV16\" (6/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_uAK1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:01:04\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_ACz1HL64U_ErSV16\" (7/16)\n", + "\u001b[32m2025-05-30 12:01:04\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:01:04\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:01:04\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:01:04\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:01:04\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:01:04\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:01:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:01:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 37 (stopped at 52 epochs).\n", + "\u001b[32m2025-05-30 12:01:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/53 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0019743, rnn_1step_R2_maskV_-1.0=-0.013276279, rnn_1step_CC_maskV_-1.0=0.066796944, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91675043, val_rnn_1step_R2_maskV_-1.0=-0.058827728, val_rnn_1step_CC_maskV_-1.0=0.30772468, learning_rate=0.001\n", + "Epoch 7/53 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.96008706, rnn_1step_R2_maskV_-1.0=0.029507529, rnn_1step_CC_maskV_-1.0=0.42677024, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.87477249, val_rnn_1step_R2_maskV_-1.0=-0.011747643, val_rnn_1step_CC_maskV_-1.0=0.37787318, learning_rate=0.001\n", + "Epoch 13/53 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.77609092, rnn_1step_R2_maskV_-1.0=0.21275307, rnn_1step_CC_maskV_-1.0=0.4758811, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.74686974, val_rnn_1step_R2_maskV_-1.0=0.13127992, val_rnn_1step_CC_maskV_-1.0=0.44208646, learning_rate=0.001\n", + "Epoch 19/53 - loss=rnn_1step_loss=0.64504957, rnn_1step_R2_maskV_-1.0=0.34357172, rnn_1step_CC_maskV_-1.0=0.5956071, rnn_1step_MSE_maskV_-1.0=0.64504951, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.67898875, val_rnn_1step_R2_maskV_-1.0=0.20960467, val_rnn_1step_CC_maskV_-1.0=0.52590865, learning_rate=0.001\n", + "Epoch 25/53 - loss=rnn_1step_loss=0.566755, rnn_1step_R2_maskV_-1.0=0.41999552, rnn_1step_CC_maskV_-1.0=0.65762329, rnn_1step_MSE_maskV_-1.0=0.56675494, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64028931, val_rnn_1step_R2_maskV_-1.0=0.25619346, val_rnn_1step_CC_maskV_-1.0=0.57126606, learning_rate=0.001\n", + "Epoch 31/53 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.50692105, rnn_1step_R2_maskV_-1.0=0.47938055, rnn_1step_CC_maskV_-1.0=0.70167935, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61325794, val_rnn_1step_R2_maskV_-1.0=0.28774995, val_rnn_1step_CC_maskV_-1.0=0.60560471, learning_rate=0.001\n", + "Epoch 37/53 - loss=rnn_1step_loss=0.46527421, rnn_1step_R2_maskV_-1.0=0.52142668, rnn_1step_CC_maskV_-1.0=0.73085207, rnn_1step_MSE_maskV_-1.0=0.46527418, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60597616, val_rnn_1step_R2_maskV_-1.0=0.29610497, val_rnn_1step_CC_maskV_-1.0=0.61746663, learning_rate=0.001\n", + "Epoch 43/53 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.44058433, rnn_1step_R2_maskV_-1.0=0.54589033, rnn_1step_CC_maskV_-1.0=0.74765992, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62891078, val_rnn_1step_R2_maskV_-1.0=0.26916927, val_rnn_1step_CC_maskV_-1.0=0.61033863, learning_rate=0.001\n", + "Epoch 49/53 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42644867, rnn_1step_R2_maskV_-1.0=0.56029165, rnn_1step_CC_maskV_-1.0=0.75755519, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60620624, val_rnn_1step_R2_maskV_-1.0=0.29575947, val_rnn_1step_CC_maskV_-1.0=0.61857378, learning_rate=0.001\n", + "Epoch 53/53 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42151129, rnn_1step_R2_maskV_-1.0=0.5652256, rnn_1step_CC_maskV_-1.0=0.76079291, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60989034, val_rnn_1step_R2_maskV_-1.0=0.29110032, val_rnn_1step_CC_maskV_-1.0=0.62046719, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:01:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 8.37s\n", + "\u001b[32m2025-05-30 12:01:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:01:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 52 (stopped at 67 epochs).\n", + "\u001b[32m2025-05-30 12:01:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/68 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0019503, rnn_1_1step_R2_maskV_-1.0=-0.013238829, rnn_1_1step_CC_maskV_-1.0=0.054812782, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91652179, val_rnn_1_1step_R2_maskV_-1.0=-0.058492169, val_rnn_1_1step_CC_maskV_-1.0=0.25947848, learning_rate=0.001\n", + "Epoch 8/68 - loss=rnn_1_1step_loss=0.94459873, rnn_1_1step_R2_maskV_-1.0=0.045331258, rnn_1_1step_CC_maskV_-1.0=0.36561283, rnn_1_1step_MSE_maskV_-1.0=0.94459879, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.86123711, val_rnn_1_1step_R2_maskV_-1.0=0.0059059858, val_rnn_1_1step_CC_maskV_-1.0=0.34270886, learning_rate=0.001\n", + "Epoch 15/68 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.76813585, rnn_1_1step_R2_maskV_-1.0=0.22074163, rnn_1_1step_CC_maskV_-1.0=0.48920828, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.73816317, val_rnn_1_1step_R2_maskV_-1.0=0.14514163, val_rnn_1_1step_CC_maskV_-1.0=0.44656387, learning_rate=0.001\n", + "Epoch 22/68 - loss=rnn_1_1step_loss=0.63959748, rnn_1_1step_R2_maskV_-1.0=0.34925926, rnn_1_1step_CC_maskV_-1.0=0.60213143, rnn_1_1step_MSE_maskV_-1.0=0.63959754, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6547668, val_rnn_1_1step_R2_maskV_-1.0=0.23984224, val_rnn_1_1step_CC_maskV_-1.0=0.53795093, learning_rate=0.001\n", + "Epoch 29/68 - loss=rnn_1_1step_loss=0.54885846, rnn_1_1step_R2_maskV_-1.0=0.4384945, rnn_1_1step_CC_maskV_-1.0=0.67172915, rnn_1_1step_MSE_maskV_-1.0=0.5488584, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60095376, val_rnn_1_1step_R2_maskV_-1.0=0.30257416, val_rnn_1_1step_CC_maskV_-1.0=0.596802, learning_rate=0.001\n", + "Epoch 36/68 - loss=rnn_1_1step_loss=0.49414906, rnn_1_1step_R2_maskV_-1.0=0.4923023, rnn_1_1step_CC_maskV_-1.0=0.7109139, rnn_1_1step_MSE_maskV_-1.0=0.49414903, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5829801, val_rnn_1_1step_R2_maskV_-1.0=0.32387754, val_rnn_1_1step_CC_maskV_-1.0=0.62471384, learning_rate=0.001\n", + "Epoch 43/68 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44747224, rnn_1_1step_R2_maskV_-1.0=0.53957462, rnn_1_1step_CC_maskV_-1.0=0.74299526, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58779794, val_rnn_1_1step_R2_maskV_-1.0=0.31798467, val_rnn_1_1step_CC_maskV_-1.0=0.6315605, learning_rate=0.001\n", + "Epoch 50/68 - loss=rnn_1_1step_loss=0.41971171, rnn_1_1step_R2_maskV_-1.0=0.56784034, rnn_1_1step_CC_maskV_-1.0=0.7617259, rnn_1_1step_MSE_maskV_-1.0=0.41971174, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6007185, val_rnn_1_1step_R2_maskV_-1.0=0.30213183, val_rnn_1_1step_CC_maskV_-1.0=0.63164079, learning_rate=0.001\n", + "Epoch 57/68 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40612629, rnn_1_1step_R2_maskV_-1.0=0.58190417, rnn_1_1step_CC_maskV_-1.0=0.77109355, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57122374, val_rnn_1_1step_R2_maskV_-1.0=0.33712149, val_rnn_1_1step_CC_maskV_-1.0=0.6467846, learning_rate=0.001\n", + "Epoch 64/68 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39201185, rnn_1_1step_R2_maskV_-1.0=0.59601998, rnn_1_1step_CC_maskV_-1.0=0.7803129, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56776899, val_rnn_1_1step_R2_maskV_-1.0=0.34095651, val_rnn_1_1step_CC_maskV_-1.0=0.65062129, learning_rate=0.001\n", + "Epoch 68/68 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38334623, rnn_1_1step_R2_maskV_-1.0=0.60458529, rnn_1_1step_CC_maskV_-1.0=0.78561723, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56686229, val_rnn_1_1step_R2_maskV_-1.0=0.34181815, val_rnn_1_1step_CC_maskV_-1.0=0.65328991, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:01:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 9.70s\n", + "\u001b[32m2025-05-30 12:01:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.55628151)\n", + "\u001b[32m2025-05-30 12:01:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.397, R2_maskV_-1.0=0.602, CC_maskV_-1.0=0.778\n", + "\u001b[32m2025-05-30 12:01:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.539, R2_maskV_-1.0=0.39, CC_maskV_-1.0=0.666\n", + "\u001b[32m2025-05-30 12:01:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:01:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:01:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 125 (stopped at 140 epochs).\n", + "\u001b[32m2025-05-30 12:01:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/141 - loss=1.6127623, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.052105699, MSE_maskV_-1.0=1.6111363, val_loss=1.0496135, val_CC_maskV_-1.0=0.15787126, val_MSE_maskV_-1.0=1.0460265, learning_rate=0.001\n", + "Epoch 16/141 - loss=0.77742225, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47432205, MSE_maskV_-1.0=0.77701163, val_loss=0.80714917, val_CC_maskV_-1.0=0.46426544, val_MSE_maskV_-1.0=0.80447012, learning_rate=0.001\n", + "Epoch 31/141 - loss=0.74146318, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51080942, MSE_maskV_-1.0=0.7415176, val_loss=0.77243662, val_CC_maskV_-1.0=0.49974969, val_MSE_maskV_-1.0=0.77017146, learning_rate=0.001\n", + "Epoch 46/141 - loss=0.7261138, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52472389, MSE_maskV_-1.0=0.72696829, val_loss=0.75869906, val_CC_maskV_-1.0=0.51189214, val_MSE_maskV_-1.0=0.756378, learning_rate=0.001\n", + "Epoch 61/141 - loss=0.71865159, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5313713, MSE_maskV_-1.0=0.71937138, val_loss=0.75205112, val_CC_maskV_-1.0=0.5170083, val_MSE_maskV_-1.0=0.74978274, learning_rate=0.001\n", + "Epoch 76/141 - loss=0.71474934, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53406429, MSE_maskV_-1.0=0.71463853, val_loss=0.74751443, val_CC_maskV_-1.0=0.5209673, val_MSE_maskV_-1.0=0.74506932, learning_rate=0.001\n", + "Epoch 91/141 - loss=0.71265447, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53625184, MSE_maskV_-1.0=0.71293426, val_loss=0.74445903, val_CC_maskV_-1.0=0.52347803, val_MSE_maskV_-1.0=0.74211347, learning_rate=0.001\n", + "Epoch 106/141 - loss=0.71132302, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53694493, MSE_maskV_-1.0=0.71228045, val_loss=0.74240744, val_CC_maskV_-1.0=0.52512908, val_MSE_maskV_-1.0=0.73998088, learning_rate=0.001\n", + "Epoch 121/141 - loss=0.71052819, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53740096, MSE_maskV_-1.0=0.71055239, val_loss=0.74078411, val_CC_maskV_-1.0=0.52726603, val_MSE_maskV_-1.0=0.73810691, learning_rate=0.001\n", + "Epoch 136/141 - loss=0.70980167, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53829253, MSE_maskV_-1.0=0.71077335, val_loss=0.74127036, val_CC_maskV_-1.0=0.52702582, val_MSE_maskV_-1.0=0.73881269, learning_rate=0.001\n", + "Epoch 141/141 - loss=0.70979607, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5386281, MSE_maskV_-1.0=0.70899904, val_loss=0.74015611, val_CC_maskV_-1.0=0.52726316, val_MSE_maskV_-1.0=0.73791778, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:01:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 34.84s\n", + "\u001b[32m2025-05-30 12:01:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:02:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 145 (stopped at 160 epochs).\n", + "\u001b[32m2025-05-30 12:02:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/161 - loss=1.4948078, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.046664607, MSE_maskV_-1.0=1.4935969, val_loss=1.0574851, val_CC_maskV_-1.0=0.1475441, val_MSE_maskV_-1.0=1.0523058, learning_rate=0.001\n", + "Epoch 18/161 - loss=0.77253246, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4801046, MSE_maskV_-1.0=0.77275223, val_loss=0.80194193, val_CC_maskV_-1.0=0.47017717, val_MSE_maskV_-1.0=0.79952592, learning_rate=0.001\n", + "Epoch 35/161 - loss=0.73717201, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51441967, MSE_maskV_-1.0=0.73676062, val_loss=0.7675299, val_CC_maskV_-1.0=0.50377798, val_MSE_maskV_-1.0=0.76524186, learning_rate=0.001\n", + "Epoch 52/161 - loss=0.72318244, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52651042, MSE_maskV_-1.0=0.72372103, val_loss=0.75601357, val_CC_maskV_-1.0=0.51420665, val_MSE_maskV_-1.0=0.75368959, learning_rate=0.001\n", + "Epoch 69/161 - loss=0.71667081, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53200763, MSE_maskV_-1.0=0.71700656, val_loss=0.74914432, val_CC_maskV_-1.0=0.52014363, val_MSE_maskV_-1.0=0.74665749, learning_rate=0.001\n", + "Epoch 86/161 - loss=0.71340418, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53478074, MSE_maskV_-1.0=0.71554029, val_loss=0.74815524, val_CC_maskV_-1.0=0.5207696, val_MSE_maskV_-1.0=0.74586868, learning_rate=0.001\n", + "Epoch 103/161 - loss=0.71143645, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53689319, MSE_maskV_-1.0=0.71148598, val_loss=0.74161577, val_CC_maskV_-1.0=0.52551043, val_MSE_maskV_-1.0=0.73947608, learning_rate=0.001\n", + "Epoch 120/161 - loss=0.71065068, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53734338, MSE_maskV_-1.0=0.71004689, val_loss=0.74139112, val_CC_maskV_-1.0=0.5261867, val_MSE_maskV_-1.0=0.73918027, learning_rate=0.001\n", + "Epoch 137/161 - loss=0.70972133, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53817981, MSE_maskV_-1.0=0.70991969, val_loss=0.74197608, val_CC_maskV_-1.0=0.52524143, val_MSE_maskV_-1.0=0.74006486, learning_rate=0.001\n", + "Epoch 154/161 - loss=0.70943666, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53761411, MSE_maskV_-1.0=0.709162, val_loss=0.74247026, val_CC_maskV_-1.0=0.52520746, val_MSE_maskV_-1.0=0.74024731, learning_rate=0.001\n", + "Epoch 161/161 - loss=0.70932907, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53853375, MSE_maskV_-1.0=0.70917046, val_loss=0.74162519, val_CC_maskV_-1.0=0.52648568, val_MSE_maskV_-1.0=0.73921692, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:02:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 39.60s\n", + "\u001b[32m2025-05-30 12:02:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.73990196)\n", + "\u001b[32m2025-05-30 12:02:39\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 736us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:02:39\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.708, R2_maskV_-1.0=0.291, CC_maskV_-1.0=0.54\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 819us/step\n", + "51/51 [==============================] - 0s 716us/step\n", + "84/84 [==============================] - 0s 685us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:02:40\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_ACz1HL64U_ErSV16\" (7/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_ACz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:02:40\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_ACy1HL64U_ErSV16\" (8/16)\n", + "\u001b[32m2025-05-30 12:02:40\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:02:40\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:02:40\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:02:40\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:02:40\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:02:40\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:02:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:02:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 77 (stopped at 92 epochs).\n", + "\u001b[32m2025-05-30 12:02:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.99814636, rnn_1step_R2_maskV_-1.0=-0.009328004, rnn_1step_CC_maskV_-1.0=0.096675634, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91082317, val_rnn_1step_R2_maskV_-1.0=-0.051975578, val_rnn_1step_CC_maskV_-1.0=0.17083651, learning_rate=0.001\n", + "Epoch 11/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.83549428, rnn_1step_R2_maskV_-1.0=0.15219823, rnn_1step_CC_maskV_-1.0=0.41566879, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.77641433, val_rnn_1step_R2_maskV_-1.0=0.097681031, val_rnn_1step_CC_maskV_-1.0=0.39806405, learning_rate=0.001\n", + "Epoch 21/93 - loss=rnn_1step_loss=0.63933462, rnn_1step_R2_maskV_-1.0=0.34889415, rnn_1step_CC_maskV_-1.0=0.60098869, rnn_1step_MSE_maskV_-1.0=0.63933456, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64769441, val_rnn_1step_R2_maskV_-1.0=0.24620202, val_rnn_1step_CC_maskV_-1.0=0.5480606, learning_rate=0.001\n", + "Epoch 31/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.55171275, rnn_1step_R2_maskV_-1.0=0.43493021, rnn_1step_CC_maskV_-1.0=0.66879123, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63903946, val_rnn_1step_R2_maskV_-1.0=0.25810426, val_rnn_1step_CC_maskV_-1.0=0.57347983, learning_rate=0.001\n", + "Epoch 41/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.50751591, rnn_1step_R2_maskV_-1.0=0.4785012, rnn_1step_CC_maskV_-1.0=0.70089966, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63711971, val_rnn_1step_R2_maskV_-1.0=0.26085842, val_rnn_1step_CC_maskV_-1.0=0.59014815, learning_rate=0.001\n", + "Epoch 51/93 - loss=rnn_1step_loss=0.47210965, rnn_1step_R2_maskV_-1.0=0.51342285, rnn_1step_CC_maskV_-1.0=0.72589773, rnn_1step_MSE_maskV_-1.0=0.47210962, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63494486, val_rnn_1step_R2_maskV_-1.0=0.26313186, val_rnn_1step_CC_maskV_-1.0=0.59982181, learning_rate=0.001\n", + "Epoch 61/93 - loss=rnn_1step_loss=0.4456149, rnn_1step_R2_maskV_-1.0=0.53964138, rnn_1step_CC_maskV_-1.0=0.74412894, rnn_1step_MSE_maskV_-1.0=0.44561487, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64135069, val_rnn_1step_R2_maskV_-1.0=0.25507858, val_rnn_1step_CC_maskV_-1.0=0.60243422, learning_rate=0.001\n", + "Epoch 71/93 - loss=rnn_1step_loss=0.42583558, rnn_1step_R2_maskV_-1.0=0.55956972, rnn_1step_CC_maskV_-1.0=0.75758314, rnn_1step_MSE_maskV_-1.0=0.42583555, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63535875, val_rnn_1step_R2_maskV_-1.0=0.26184797, val_rnn_1step_CC_maskV_-1.0=0.60395694, learning_rate=0.001\n", + "Epoch 81/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41527948, rnn_1step_R2_maskV_-1.0=0.57048869, rnn_1step_CC_maskV_-1.0=0.76441538, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61492401, val_rnn_1step_R2_maskV_-1.0=0.2852217, val_rnn_1step_CC_maskV_-1.0=0.61616707, learning_rate=0.001\n", + "Epoch 91/93 - loss=rnn_1step_loss=0.40500566, rnn_1step_R2_maskV_-1.0=0.58092511, rnn_1step_CC_maskV_-1.0=0.77113616, rnn_1step_MSE_maskV_-1.0=0.40500563, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61298305, val_rnn_1step_R2_maskV_-1.0=0.28703034, val_rnn_1step_CC_maskV_-1.0=0.62547147, learning_rate=0.001\n", + "Epoch 93/93 - loss=rnn_1step_loss=0.4018414, rnn_1step_R2_maskV_-1.0=0.5841285, rnn_1step_CC_maskV_-1.0=0.77323055, rnn_1step_MSE_maskV_-1.0=0.40184137, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59813309, val_rnn_1step_R2_maskV_-1.0=0.30466291, val_rnn_1step_CC_maskV_-1.0=0.63077533, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:02:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.40s\n", + "\u001b[32m2025-05-30 12:02:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:03:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 58 (stopped at 73 epochs).\n", + "\u001b[32m2025-05-30 12:03:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/74 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.9998396, rnn_1_1step_R2_maskV_-1.0=-0.010988817, rnn_1_1step_CC_maskV_-1.0=0.073592402, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91180682, val_rnn_1_1step_R2_maskV_-1.0=-0.053418189, val_rnn_1_1step_CC_maskV_-1.0=0.18036401, learning_rate=0.001\n", + "Epoch 9/74 - loss=rnn_1_1step_loss=0.89316994, rnn_1_1step_R2_maskV_-1.0=0.096190624, rnn_1_1step_CC_maskV_-1.0=0.40284419, rnn_1_1step_MSE_maskV_-1.0=0.89316988, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.81918699, val_rnn_1_1step_R2_maskV_-1.0=0.050488189, val_rnn_1_1step_CC_maskV_-1.0=0.35402152, learning_rate=0.001\n", + "Epoch 17/74 - loss=rnn_1_1step_loss=0.73050982, rnn_1_1step_R2_maskV_-1.0=0.25786126, rnn_1_1step_CC_maskV_-1.0=0.52410269, rnn_1_1step_MSE_maskV_-1.0=0.73050988, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.69366604, val_rnn_1_1step_R2_maskV_-1.0=0.19272302, val_rnn_1_1step_CC_maskV_-1.0=0.49441266, learning_rate=0.001\n", + "Epoch 25/74 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.60546589, rnn_1_1step_R2_maskV_-1.0=0.38280582, rnn_1_1step_CC_maskV_-1.0=0.62753367, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64641517, val_rnn_1_1step_R2_maskV_-1.0=0.24796262, val_rnn_1_1step_CC_maskV_-1.0=0.56519717, learning_rate=0.001\n", + "Epoch 33/74 - loss=rnn_1_1step_loss=0.52762461, rnn_1_1step_R2_maskV_-1.0=0.4586314, rnn_1_1step_CC_maskV_-1.0=0.68664831, rnn_1_1step_MSE_maskV_-1.0=0.52762467, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65049523, val_rnn_1_1step_R2_maskV_-1.0=0.24435875, val_rnn_1_1step_CC_maskV_-1.0=0.58014679, learning_rate=0.001\n", + "Epoch 41/74 - loss=rnn_1_1step_loss=0.47978958, rnn_1_1step_R2_maskV_-1.0=0.50624472, rnn_1_1step_CC_maskV_-1.0=0.72114199, rnn_1_1step_MSE_maskV_-1.0=0.47978956, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64691848, val_rnn_1_1step_R2_maskV_-1.0=0.24783313, val_rnn_1_1step_CC_maskV_-1.0=0.59451568, learning_rate=0.001\n", + "Epoch 49/74 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.45519629, rnn_1_1step_R2_maskV_-1.0=0.53110433, rnn_1_1step_CC_maskV_-1.0=0.73771459, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6280672, val_rnn_1_1step_R2_maskV_-1.0=0.2692416, val_rnn_1_1step_CC_maskV_-1.0=0.60916877, learning_rate=0.001\n", + "Epoch 57/74 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.43771699, rnn_1_1step_R2_maskV_-1.0=0.54887176, rnn_1_1step_CC_maskV_-1.0=0.75003552, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63879639, val_rnn_1_1step_R2_maskV_-1.0=0.25630188, val_rnn_1_1step_CC_maskV_-1.0=0.61229998, learning_rate=0.001\n", + "Epoch 65/74 - loss=rnn_1_1step_loss=0.42464221, rnn_1_1step_R2_maskV_-1.0=0.56207901, rnn_1_1step_CC_maskV_-1.0=0.75816131, rnn_1_1step_MSE_maskV_-1.0=0.42464218, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60657197, val_rnn_1_1step_R2_maskV_-1.0=0.29362023, val_rnn_1_1step_CC_maskV_-1.0=0.62758005, learning_rate=0.001\n", + "Epoch 73/74 - loss=rnn_1_1step_loss=0.41360641, rnn_1_1step_R2_maskV_-1.0=0.57330662, rnn_1_1step_CC_maskV_-1.0=0.76547754, rnn_1_1step_MSE_maskV_-1.0=0.41360644, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60866302, val_rnn_1_1step_R2_maskV_-1.0=0.29121581, val_rnn_1_1step_CC_maskV_-1.0=0.62612057, learning_rate=0.001\n", + "Epoch 74/74 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41191784, rnn_1_1step_R2_maskV_-1.0=0.57499921, rnn_1_1step_CC_maskV_-1.0=0.76666975, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62273228, val_rnn_1_1step_R2_maskV_-1.0=0.27474877, val_rnn_1_1step_CC_maskV_-1.0=0.6222958, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:03:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.38s\n", + "\u001b[32m2025-05-30 12:03:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.58457476)\n", + "\u001b[32m2025-05-30 12:03:04\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.41, R2_maskV_-1.0=0.589, CC_maskV_-1.0=0.768\n", + "\u001b[32m2025-05-30 12:03:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.564, R2_maskV_-1.0=0.358, CC_maskV_-1.0=0.655\n", + "\u001b[32m2025-05-30 12:03:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:03:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:03:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 156 (stopped at 171 epochs).\n", + "\u001b[32m2025-05-30 12:03:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/172 - loss=1.0144298, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.20256436, MSE_maskV_-1.0=1.0144361, val_loss=0.92410737, val_CC_maskV_-1.0=0.31580278, val_MSE_maskV_-1.0=0.92160338, learning_rate=0.001\n", + "Epoch 19/172 - loss=0.65538234, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58583629, MSE_maskV_-1.0=0.65488613, val_loss=0.68502098, val_CC_maskV_-1.0=0.56993788, val_MSE_maskV_-1.0=0.6814664, learning_rate=0.001\n", + "Epoch 37/172 - loss=0.62591052, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60904145, MSE_maskV_-1.0=0.62601334, val_loss=0.66470999, val_CC_maskV_-1.0=0.58750921, val_MSE_maskV_-1.0=0.66081202, learning_rate=0.001\n", + "Epoch 55/172 - loss=0.61233121, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61989993, MSE_maskV_-1.0=0.61198962, val_loss=0.65548432, val_CC_maskV_-1.0=0.59478766, val_MSE_maskV_-1.0=0.65131485, learning_rate=0.001\n", + "Epoch 73/172 - loss=0.6042006, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62602282, MSE_maskV_-1.0=0.60438305, val_loss=0.65079147, val_CC_maskV_-1.0=0.59955895, val_MSE_maskV_-1.0=0.64672464, learning_rate=0.001\n", + "Epoch 91/172 - loss=0.59840298, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63104075, MSE_maskV_-1.0=0.5987246, val_loss=0.64666241, val_CC_maskV_-1.0=0.6026504, val_MSE_maskV_-1.0=0.64241594, learning_rate=0.001\n", + "Epoch 109/172 - loss=0.59453964, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63334674, MSE_maskV_-1.0=0.59426898, val_loss=0.64438152, val_CC_maskV_-1.0=0.60519642, val_MSE_maskV_-1.0=0.6404022, learning_rate=0.001\n", + "Epoch 127/172 - loss=0.59147036, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63695455, MSE_maskV_-1.0=0.59160674, val_loss=0.6441316, val_CC_maskV_-1.0=0.60570103, val_MSE_maskV_-1.0=0.64002824, learning_rate=0.001\n", + "Epoch 145/172 - loss=0.58900148, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63751256, MSE_maskV_-1.0=0.5887441, val_loss=0.64241004, val_CC_maskV_-1.0=0.60628444, val_MSE_maskV_-1.0=0.63881415, learning_rate=0.001\n", + "Epoch 163/172 - loss=0.58577031, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64054924, MSE_maskV_-1.0=0.58568734, val_loss=0.64049613, val_CC_maskV_-1.0=0.60895842, val_MSE_maskV_-1.0=0.63663501, learning_rate=0.001\n", + "Epoch 172/172 - loss=0.58499104, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64125288, MSE_maskV_-1.0=0.58559692, val_loss=0.64040393, val_CC_maskV_-1.0=0.61043483, val_MSE_maskV_-1.0=0.63595563, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:03:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 45.39s\n", + "\u001b[32m2025-05-30 12:03:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:04:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 179 (stopped at 194 epochs).\n", + "\u001b[32m2025-05-30 12:04:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/195 - loss=0.99686617, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.2123062, MSE_maskV_-1.0=0.99685353, val_loss=0.91444933, val_CC_maskV_-1.0=0.32583809, val_MSE_maskV_-1.0=0.91277176, learning_rate=0.001\n", + "Epoch 21/195 - loss=0.65034521, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58915514, MSE_maskV_-1.0=0.650334, val_loss=0.68118382, val_CC_maskV_-1.0=0.57294941, val_MSE_maskV_-1.0=0.67790014, learning_rate=0.001\n", + "Epoch 41/195 - loss=0.62048715, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61440271, MSE_maskV_-1.0=0.62159789, val_loss=0.66224074, val_CC_maskV_-1.0=0.58912885, val_MSE_maskV_-1.0=0.65872836, learning_rate=0.001\n", + "Epoch 61/195 - loss=0.60738587, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62477273, MSE_maskV_-1.0=0.60771263, val_loss=0.65167022, val_CC_maskV_-1.0=0.59758168, val_MSE_maskV_-1.0=0.64830536, learning_rate=0.001\n", + "Epoch 81/195 - loss=0.60009098, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.629933, MSE_maskV_-1.0=0.60023445, val_loss=0.64567316, val_CC_maskV_-1.0=0.60298705, val_MSE_maskV_-1.0=0.64235365, learning_rate=0.001\n", + "Epoch 101/195 - loss=0.59472281, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63407862, MSE_maskV_-1.0=0.59422415, val_loss=0.64259154, val_CC_maskV_-1.0=0.60613304, val_MSE_maskV_-1.0=0.63918519, learning_rate=0.001\n", + "Epoch 121/195 - loss=0.59068894, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63645852, MSE_maskV_-1.0=0.5908218, val_loss=0.64038825, val_CC_maskV_-1.0=0.60861021, val_MSE_maskV_-1.0=0.63621557, learning_rate=0.001\n", + "Epoch 141/195 - loss=0.58606058, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64079487, MSE_maskV_-1.0=0.58538014, val_loss=0.63656187, val_CC_maskV_-1.0=0.61226404, val_MSE_maskV_-1.0=0.6326437, learning_rate=0.001\n", + "Epoch 161/195 - loss=0.58327639, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64248484, MSE_maskV_-1.0=0.58329117, val_loss=0.63793105, val_CC_maskV_-1.0=0.61132807, val_MSE_maskV_-1.0=0.63388789, learning_rate=0.001\n", + "Epoch 181/195 - loss=0.58134288, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6453979, MSE_maskV_-1.0=0.58154416, val_loss=0.63879603, val_CC_maskV_-1.0=0.61098212, val_MSE_maskV_-1.0=0.63479674, learning_rate=0.001\n", + "Epoch 195/195 - loss=0.57983536, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64463538, MSE_maskV_-1.0=0.57946706, val_loss=0.63607824, val_CC_maskV_-1.0=0.61386043, val_MSE_maskV_-1.0=0.63196301, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:04:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 51.75s\n", + "\u001b[32m2025-05-30 12:04:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.63457078)\n", + "\u001b[32m2025-05-30 12:04:42\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 823us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:04:42\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.577, R2_maskV_-1.0=0.426, CC_maskV_-1.0=0.651\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 897us/step\n", + "51/51 [==============================] - 0s 833us/step\n", + "84/84 [==============================] - 0s 853us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:04:43\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_ACy1HL64U_ErSV16\" (8/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_ACy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:04:43\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_KCz1HL64U_ErSV16\" (9/16)\n", + "\u001b[32m2025-05-30 12:04:43\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:04:43\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:04:43\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:04:43\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:04:43\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:04:43\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:04:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:05:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 149 (stopped at 164 epochs).\n", + "\u001b[32m2025-05-30 12:05:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/165 - loss=rnn_1step_loss=1.002304, rnn_1step_R2_maskV_-1.0=-0.013639003, rnn_1step_CC_maskV_-1.0=0.031183336, rnn_1step_MSE_maskV_-1.0=1.0023041, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91796082, val_rnn_1step_R2_maskV_-1.0=-0.060165137, val_rnn_1step_CC_maskV_-1.0=0.22940759, learning_rate=0.001\n", + "Epoch 18/165 - loss=rnn_1step_loss=0.6811946, rnn_1step_R2_maskV_-1.0=0.30489808, rnn_1step_CC_maskV_-1.0=0.56607866, rnn_1step_MSE_maskV_-1.0=0.68119454, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.69165802, val_rnn_1step_R2_maskV_-1.0=0.19787121, val_rnn_1step_CC_maskV_-1.0=0.50749826, learning_rate=0.001\n", + "Epoch 35/165 - loss=rnn_1step_loss=0.52938873, rnn_1step_R2_maskV_-1.0=0.45735833, rnn_1step_CC_maskV_-1.0=0.68652588, rnn_1step_MSE_maskV_-1.0=0.52938879, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64204425, val_rnn_1step_R2_maskV_-1.0=0.25696534, val_rnn_1step_CC_maskV_-1.0=0.57444167, learning_rate=0.001\n", + "Epoch 52/165 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39169514, rnn_1step_R2_maskV_-1.0=0.5978663, rnn_1step_CC_maskV_-1.0=0.78007424, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5701589, val_rnn_1step_R2_maskV_-1.0=0.33897072, val_rnn_1step_CC_maskV_-1.0=0.6514433, learning_rate=0.001\n", + "Epoch 69/165 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33048636, rnn_1step_R2_maskV_-1.0=0.66010892, rnn_1step_CC_maskV_-1.0=0.81825721, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54952335, val_rnn_1step_R2_maskV_-1.0=0.36192927, val_rnn_1step_CC_maskV_-1.0=0.67402071, learning_rate=0.001\n", + "Epoch 86/165 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.28859481, rnn_1step_R2_maskV_-1.0=0.70329762, rnn_1step_CC_maskV_-1.0=0.84341222, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53894979, val_rnn_1step_R2_maskV_-1.0=0.37377638, val_rnn_1step_CC_maskV_-1.0=0.68297738, learning_rate=0.001\n", + "Epoch 103/165 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.25650525, rnn_1step_R2_maskV_-1.0=0.73584288, rnn_1step_CC_maskV_-1.0=0.8625741, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53923303, val_rnn_1step_R2_maskV_-1.0=0.37259111, val_rnn_1step_CC_maskV_-1.0=0.68689275, learning_rate=0.001\n", + "Epoch 120/165 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.21115975, rnn_1step_R2_maskV_-1.0=0.78245866, rnn_1step_CC_maskV_-1.0=0.88824463, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51062369, val_rnn_1step_R2_maskV_-1.0=0.40616998, val_rnn_1step_CC_maskV_-1.0=0.70464092, learning_rate=0.001\n", + "Epoch 137/165 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.19090813, rnn_1step_R2_maskV_-1.0=0.80275697, rnn_1step_CC_maskV_-1.0=0.90013003, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52195805, val_rnn_1step_R2_maskV_-1.0=0.3917892, val_rnn_1step_CC_maskV_-1.0=0.70198882, learning_rate=0.001\n", + "Epoch 154/165 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.17238212, rnn_1step_R2_maskV_-1.0=0.82170886, rnn_1step_CC_maskV_-1.0=0.90988404, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50296593, val_rnn_1step_R2_maskV_-1.0=0.41500109, val_rnn_1step_CC_maskV_-1.0=0.7131632, learning_rate=0.001\n", + "Epoch 165/165 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.16464396, rnn_1step_R2_maskV_-1.0=0.82944685, rnn_1step_CC_maskV_-1.0=0.91411275, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49094579, val_rnn_1step_R2_maskV_-1.0=0.42938375, val_rnn_1step_CC_maskV_-1.0=0.71867949, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:05:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 19.32s\n", + "\u001b[32m2025-05-30 12:05:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:05:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 126 (stopped at 141 epochs).\n", + "\u001b[32m2025-05-30 12:05:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/142 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0024009, rnn_1_1step_R2_maskV_-1.0=-0.013730399, rnn_1_1step_CC_maskV_-1.0=0.006974753, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91794658, val_rnn_1_1step_R2_maskV_-1.0=-0.060163006, val_rnn_1_1step_CC_maskV_-1.0=0.25987393, learning_rate=0.001\n", + "Epoch 16/142 - loss=rnn_1_1step_loss=0.77309752, rnn_1_1step_R2_maskV_-1.0=0.21477988, rnn_1_1step_CC_maskV_-1.0=0.4823885, rnn_1_1step_MSE_maskV_-1.0=0.77309757, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.72677463, val_rnn_1_1step_R2_maskV_-1.0=0.15406995, val_rnn_1_1step_CC_maskV_-1.0=0.45625007, learning_rate=0.001\n", + "Epoch 31/142 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.57805032, rnn_1_1step_R2_maskV_-1.0=0.41059941, rnn_1_1step_CC_maskV_-1.0=0.65064061, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64967191, val_rnn_1_1step_R2_maskV_-1.0=0.24187368, val_rnn_1_1step_CC_maskV_-1.0=0.55219859, learning_rate=0.001\n", + "Epoch 46/142 - loss=rnn_1_1step_loss=0.45401302, rnn_1_1step_R2_maskV_-1.0=0.53677058, rnn_1_1step_CC_maskV_-1.0=0.73914564, rnn_1_1step_MSE_maskV_-1.0=0.45401305, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58864534, val_rnn_1_1step_R2_maskV_-1.0=0.31417555, val_rnn_1_1step_CC_maskV_-1.0=0.61634427, learning_rate=0.001\n", + "Epoch 61/142 - loss=rnn_1_1step_loss=0.35855976, rnn_1_1step_R2_maskV_-1.0=0.63195193, rnn_1_1step_CC_maskV_-1.0=0.80102146, rnn_1_1step_MSE_maskV_-1.0=0.35855979, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54210502, val_rnn_1_1step_R2_maskV_-1.0=0.36934444, val_rnn_1_1step_CC_maskV_-1.0=0.66805649, learning_rate=0.001\n", + "Epoch 76/142 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30639923, rnn_1_1step_R2_maskV_-1.0=0.68537438, rnn_1_1step_CC_maskV_-1.0=0.83296037, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52166069, val_rnn_1_1step_R2_maskV_-1.0=0.39259648, val_rnn_1_1step_CC_maskV_-1.0=0.68962759, learning_rate=0.001\n", + "Epoch 91/142 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.26399159, rnn_1_1step_R2_maskV_-1.0=0.72939134, rnn_1_1step_CC_maskV_-1.0=0.85818392, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51526231, val_rnn_1_1step_R2_maskV_-1.0=0.3999992, val_rnn_1_1step_CC_maskV_-1.0=0.69956124, learning_rate=0.001\n", + "Epoch 106/142 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.23799825, rnn_1_1step_R2_maskV_-1.0=0.75620103, rnn_1_1step_CC_maskV_-1.0=0.87324256, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52459311, val_rnn_1_1step_R2_maskV_-1.0=0.38903666, val_rnn_1_1step_CC_maskV_-1.0=0.70144856, learning_rate=0.001\n", + "Epoch 121/142 - loss=rnn_1_1step_loss=0.21650131, rnn_1_1step_R2_maskV_-1.0=0.77782452, rnn_1_1step_CC_maskV_-1.0=0.88547862, rnn_1_1step_MSE_maskV_-1.0=0.21650134, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50694734, val_rnn_1_1step_R2_maskV_-1.0=0.4101879, val_rnn_1_1step_CC_maskV_-1.0=0.71142995, learning_rate=0.001\n", + "Epoch 136/142 - loss=rnn_1_1step_loss=0.19966413, rnn_1_1step_R2_maskV_-1.0=0.79474771, rnn_1_1step_CC_maskV_-1.0=0.89502829, rnn_1_1step_MSE_maskV_-1.0=0.19966412, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51995772, val_rnn_1_1step_R2_maskV_-1.0=0.39506149, val_rnn_1_1step_CC_maskV_-1.0=0.71057022, learning_rate=0.001\n", + "Epoch 142/142 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.19667177, rnn_1_1step_R2_maskV_-1.0=0.79772574, rnn_1_1step_CC_maskV_-1.0=0.89647496, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51048797, val_rnn_1_1step_R2_maskV_-1.0=0.40645307, val_rnn_1_1step_CC_maskV_-1.0=0.71453524, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:05:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 16.90s\n", + "\u001b[32m2025-05-30 12:05:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.48307982)\n", + "\u001b[32m2025-05-30 12:05:21\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.165, R2_maskV_-1.0=0.835, CC_maskV_-1.0=0.914\n", + "\u001b[32m2025-05-30 12:05:21\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.439, R2_maskV_-1.0=0.502, CC_maskV_-1.0=0.75\n", + "\u001b[32m2025-05-30 12:05:21\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:05:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:07:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 425 (stopped at 440 epochs).\n", + "\u001b[32m2025-05-30 12:07:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/441 - loss=2.5907927, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.015254918, MSE_maskV_-1.0=2.5869231, val_loss=1.268768, val_CC_maskV_-1.0=0.046210837, val_MSE_maskV_-1.0=1.267969, learning_rate=0.001\n", + "Epoch 46/441 - loss=0.86727971, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36669579, MSE_maskV_-1.0=0.86854738, val_loss=0.89345199, val_CC_maskV_-1.0=0.36970815, val_MSE_maskV_-1.0=0.88985854, learning_rate=0.001\n", + "Epoch 91/441 - loss=0.84708053, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39438266, MSE_maskV_-1.0=0.84744835, val_loss=0.87723702, val_CC_maskV_-1.0=0.39203498, val_MSE_maskV_-1.0=0.87304986, learning_rate=0.001\n", + "Epoch 136/441 - loss=0.83337164, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41138375, MSE_maskV_-1.0=0.83429557, val_loss=0.86554098, val_CC_maskV_-1.0=0.40644759, val_MSE_maskV_-1.0=0.86160868, learning_rate=0.001\n", + "Epoch 181/441 - loss=0.82505465, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42138618, MSE_maskV_-1.0=0.82578909, val_loss=0.85734785, val_CC_maskV_-1.0=0.41625679, val_MSE_maskV_-1.0=0.85363156, learning_rate=0.001\n", + "Epoch 226/441 - loss=0.81861526, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42798054, MSE_maskV_-1.0=0.81825107, val_loss=0.85018951, val_CC_maskV_-1.0=0.42476791, val_MSE_maskV_-1.0=0.84642768, learning_rate=0.001\n", + "Epoch 271/441 - loss=0.81356794, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43446961, MSE_maskV_-1.0=0.81353951, val_loss=0.84690154, val_CC_maskV_-1.0=0.42942879, val_MSE_maskV_-1.0=0.84240758, learning_rate=0.001\n", + "Epoch 316/441 - loss=0.80927938, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43923688, MSE_maskV_-1.0=0.80932289, val_loss=0.84157133, val_CC_maskV_-1.0=0.43382028, val_MSE_maskV_-1.0=0.83861238, learning_rate=0.001\n", + "Epoch 361/441 - loss=0.80632669, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44206825, MSE_maskV_-1.0=0.80697024, val_loss=0.83799869, val_CC_maskV_-1.0=0.43792653, val_MSE_maskV_-1.0=0.83448684, learning_rate=0.001\n", + "Epoch 406/441 - loss=0.80345547, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44522783, MSE_maskV_-1.0=0.80382168, val_loss=0.83484364, val_CC_maskV_-1.0=0.44209492, val_MSE_maskV_-1.0=0.83097631, learning_rate=0.001\n", + "Epoch 441/441 - loss=0.80204111, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44702527, MSE_maskV_-1.0=0.80155081, val_loss=0.83567232, val_CC_maskV_-1.0=0.44025376, val_MSE_maskV_-1.0=0.83200759, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:07:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 108.52s\n", + "\u001b[32m2025-05-30 12:07:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:08:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 425 (stopped at 440 epochs).\n", + "\u001b[32m2025-05-30 12:08:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/441 - loss=2.4796143, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.00068005442, MSE_maskV_-1.0=2.4758277, val_loss=1.3109859, val_CC_maskV_-1.0=0.016036302, val_MSE_maskV_-1.0=1.3099535, learning_rate=0.001\n", + "Epoch 46/441 - loss=0.8650372, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36989236, MSE_maskV_-1.0=0.86630672, val_loss=0.89229691, val_CC_maskV_-1.0=0.37133452, val_MSE_maskV_-1.0=0.88866442, learning_rate=0.001\n", + "Epoch 91/441 - loss=0.84538043, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39669663, MSE_maskV_-1.0=0.84574425, val_loss=0.87632227, val_CC_maskV_-1.0=0.39316601, val_MSE_maskV_-1.0=0.87212718, learning_rate=0.001\n", + "Epoch 136/441 - loss=0.83193064, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41326016, MSE_maskV_-1.0=0.83284968, val_loss=0.86465782, val_CC_maskV_-1.0=0.40747023, val_MSE_maskV_-1.0=0.86071545, learning_rate=0.001\n", + "Epoch 181/441 - loss=0.8238557, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42292356, MSE_maskV_-1.0=0.82458079, val_loss=0.85637403, val_CC_maskV_-1.0=0.41726503, val_MSE_maskV_-1.0=0.85268098, learning_rate=0.001\n", + "Epoch 226/441 - loss=0.81760627, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42921671, MSE_maskV_-1.0=0.81723124, val_loss=0.84951144, val_CC_maskV_-1.0=0.42537928, val_MSE_maskV_-1.0=0.84575558, learning_rate=0.001\n", + "Epoch 271/441 - loss=0.81271857, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43546197, MSE_maskV_-1.0=0.81268388, val_loss=0.84625512, val_CC_maskV_-1.0=0.42998192, val_MSE_maskV_-1.0=0.84178376, learning_rate=0.001\n", + "Epoch 316/441 - loss=0.80856407, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44006857, MSE_maskV_-1.0=0.80861175, val_loss=0.84108478, val_CC_maskV_-1.0=0.43415123, val_MSE_maskV_-1.0=0.83816034, learning_rate=0.001\n", + "Epoch 361/441 - loss=0.80571979, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44273928, MSE_maskV_-1.0=0.80636913, val_loss=0.83763355, val_CC_maskV_-1.0=0.43813255, val_MSE_maskV_-1.0=0.834153, learning_rate=0.001\n", + "Epoch 406/441 - loss=0.80292875, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44579133, MSE_maskV_-1.0=0.8033008, val_loss=0.83448112, val_CC_maskV_-1.0=0.44229731, val_MSE_maskV_-1.0=0.83064687, learning_rate=0.001\n", + "Epoch 441/441 - loss=0.80157143, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44752207, MSE_maskV_-1.0=0.80108541, val_loss=0.83533019, val_CC_maskV_-1.0=0.44045347, val_MSE_maskV_-1.0=0.83169472, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:08:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 109.46s\n", + "\u001b[32m2025-05-30 12:08:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.83250028)\n", + "\u001b[32m2025-05-30 12:08:59\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 754us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:09:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.8, R2_maskV_-1.0=0.2, CC_maskV_-1.0=0.449\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 761us/step\n", + "51/51 [==============================] - 0s 718us/step\n", + "84/84 [==============================] - 0s 709us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:09:00\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_KCz1HL64U_ErSV16\" (9/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_KCz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:09:00\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_KCy1HL64U_ErSV16\" (10/16)\n", + "\u001b[32m2025-05-30 12:09:00\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:09:00\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:09:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:09:01\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:09:01\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:09:01\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:09:01\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:09:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 70 (stopped at 85 epochs).\n", + "\u001b[32m2025-05-30 12:09:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/86 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0016538, rnn_1step_R2_maskV_-1.0=-0.012912281, rnn_1step_CC_maskV_-1.0=0.091409162, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91677397, val_rnn_1step_R2_maskV_-1.0=-0.058878824, val_rnn_1step_CC_maskV_-1.0=0.23251873, learning_rate=0.001\n", + "Epoch 10/86 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.85693032, rnn_1step_R2_maskV_-1.0=0.12985456, rnn_1step_CC_maskV_-1.0=0.38684723, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.79124331, val_rnn_1step_R2_maskV_-1.0=0.080857307, val_rnn_1step_CC_maskV_-1.0=0.3775627, learning_rate=0.001\n", + "Epoch 19/86 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.68472081, rnn_1step_R2_maskV_-1.0=0.30177426, rnn_1step_CC_maskV_-1.0=0.56255281, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.68186045, val_rnn_1step_R2_maskV_-1.0=0.20639636, val_rnn_1step_CC_maskV_-1.0=0.51712769, learning_rate=0.001\n", + "Epoch 28/86 - loss=rnn_1step_loss=0.5771234, rnn_1step_R2_maskV_-1.0=0.41058421, rnn_1step_CC_maskV_-1.0=0.65095365, rnn_1step_MSE_maskV_-1.0=0.57712346, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63402373, val_rnn_1step_R2_maskV_-1.0=0.26279569, val_rnn_1step_CC_maskV_-1.0=0.56810212, learning_rate=0.001\n", + "Epoch 37/86 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4897894, rnn_1step_R2_maskV_-1.0=0.4996298, rnn_1step_CC_maskV_-1.0=0.71422631, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59616107, val_rnn_1step_R2_maskV_-1.0=0.30771285, val_rnn_1step_CC_maskV_-1.0=0.60849482, learning_rate=0.001\n", + "Epoch 46/86 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40764299, rnn_1step_R2_maskV_-1.0=0.58338267, rnn_1step_CC_maskV_-1.0=0.76948017, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56153721, val_rnn_1step_R2_maskV_-1.0=0.34751999, val_rnn_1step_CC_maskV_-1.0=0.65025359, learning_rate=0.001\n", + "Epoch 55/86 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35054889, rnn_1step_R2_maskV_-1.0=0.64233047, rnn_1step_CC_maskV_-1.0=0.80585396, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5260759, val_rnn_1step_R2_maskV_-1.0=0.38915598, val_rnn_1step_CC_maskV_-1.0=0.67785412, learning_rate=0.001\n", + "Epoch 64/86 - loss=rnn_1step_loss=0.30259752, rnn_1step_R2_maskV_-1.0=0.69145906, rnn_1step_CC_maskV_-1.0=0.83518934, rnn_1step_MSE_maskV_-1.0=0.30259755, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4999989, val_rnn_1step_R2_maskV_-1.0=0.42052463, val_rnn_1step_CC_maskV_-1.0=0.70150495, learning_rate=0.001\n", + "Epoch 73/86 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.26290169, rnn_1step_R2_maskV_-1.0=0.73157537, rnn_1step_CC_maskV_-1.0=0.85871089, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4918189, val_rnn_1step_R2_maskV_-1.0=0.43029127, val_rnn_1step_CC_maskV_-1.0=0.71440274, learning_rate=0.001\n", + "Epoch 82/86 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.24106278, rnn_1step_R2_maskV_-1.0=0.75374985, rnn_1step_CC_maskV_-1.0=0.87135583, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49959579, val_rnn_1step_R2_maskV_-1.0=0.4211292, val_rnn_1step_CC_maskV_-1.0=0.71436781, learning_rate=0.001\n", + "Epoch 86/86 - loss=rnn_1step_loss=0.23392959, rnn_1step_R2_maskV_-1.0=0.76094908, rnn_1step_CC_maskV_-1.0=0.87543237, rnn_1step_MSE_maskV_-1.0=0.2339296, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50417107, val_rnn_1step_R2_maskV_-1.0=0.41574869, val_rnn_1step_CC_maskV_-1.0=0.71392447, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:09:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.07s\n", + "\u001b[32m2025-05-30 12:09:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:09:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 100 (stopped at 115 epochs).\n", + "\u001b[32m2025-05-30 12:09:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/116 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0017077, rnn_1_1step_R2_maskV_-1.0=-0.013026826, rnn_1_1step_CC_maskV_-1.0=0.10267103, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91704208, val_rnn_1_1step_R2_maskV_-1.0=-0.05911535, val_rnn_1_1step_CC_maskV_-1.0=0.24389644, learning_rate=0.001\n", + "Epoch 13/116 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.752415, rnn_1_1step_R2_maskV_-1.0=0.23382027, rnn_1_1step_CC_maskV_-1.0=0.50260872, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.72596616, val_rnn_1_1step_R2_maskV_-1.0=0.15867992, val_rnn_1_1step_CC_maskV_-1.0=0.47840542, learning_rate=0.001\n", + "Epoch 25/116 - loss=rnn_1_1step_loss=0.54623109, rnn_1_1step_R2_maskV_-1.0=0.44028789, rnn_1_1step_CC_maskV_-1.0=0.67295188, rnn_1_1step_MSE_maskV_-1.0=0.54623115, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61845052, val_rnn_1_1step_R2_maskV_-1.0=0.28214264, val_rnn_1_1step_CC_maskV_-1.0=0.59040576, learning_rate=0.001\n", + "Epoch 37/116 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.45050862, rnn_1_1step_R2_maskV_-1.0=0.53777552, rnn_1_1step_CC_maskV_-1.0=0.74063605, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57200867, val_rnn_1_1step_R2_maskV_-1.0=0.33511046, val_rnn_1_1step_CC_maskV_-1.0=0.63436753, learning_rate=0.001\n", + "Epoch 49/116 - loss=rnn_1_1step_loss=0.38235688, rnn_1_1step_R2_maskV_-1.0=0.60823178, rnn_1_1step_CC_maskV_-1.0=0.78564507, rnn_1_1step_MSE_maskV_-1.0=0.38235685, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53576016, val_rnn_1_1step_R2_maskV_-1.0=0.37614799, val_rnn_1_1step_CC_maskV_-1.0=0.66586822, learning_rate=0.001\n", + "Epoch 61/116 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.34719333, rnn_1_1step_R2_maskV_-1.0=0.64453429, rnn_1_1step_CC_maskV_-1.0=0.80764896, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52742505, val_rnn_1_1step_R2_maskV_-1.0=0.38598931, val_rnn_1_1step_CC_maskV_-1.0=0.67484862, learning_rate=0.001\n", + "Epoch 73/116 - loss=rnn_1_1step_loss=0.31080672, rnn_1_1step_R2_maskV_-1.0=0.68214488, rnn_1_1step_CC_maskV_-1.0=0.82987154, rnn_1_1step_MSE_maskV_-1.0=0.31080669, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51577932, val_rnn_1_1step_R2_maskV_-1.0=0.3998549, val_rnn_1_1step_CC_maskV_-1.0=0.68641895, learning_rate=0.001\n", + "Epoch 85/116 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.26331535, rnn_1_1step_R2_maskV_-1.0=0.73047709, rnn_1_1step_CC_maskV_-1.0=0.85820079, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50185961, val_rnn_1_1step_R2_maskV_-1.0=0.41635135, val_rnn_1_1step_CC_maskV_-1.0=0.70268625, learning_rate=0.001\n", + "Epoch 97/116 - loss=rnn_1_1step_loss=0.24072142, rnn_1_1step_R2_maskV_-1.0=0.75310242, rnn_1_1step_CC_maskV_-1.0=0.8718521, rnn_1_1step_MSE_maskV_-1.0=0.24072145, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50508285, val_rnn_1_1step_R2_maskV_-1.0=0.41209018, val_rnn_1_1step_CC_maskV_-1.0=0.7033934, learning_rate=0.001\n", + "Epoch 109/116 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.21065681, rnn_1_1step_R2_maskV_-1.0=0.78353435, rnn_1_1step_CC_maskV_-1.0=0.88890624, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52134627, val_rnn_1_1step_R2_maskV_-1.0=0.39352065, val_rnn_1_1step_CC_maskV_-1.0=0.70818144, learning_rate=0.001\n", + "Epoch 116/116 - loss=rnn_1_1step_loss=0.20233226, rnn_1_1step_R2_maskV_-1.0=0.7922492, rnn_1_1step_CC_maskV_-1.0=0.89323044, rnn_1_1step_MSE_maskV_-1.0=0.20233227, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50870723, val_rnn_1_1step_R2_maskV_-1.0=0.40846282, val_rnn_1_1step_CC_maskV_-1.0=0.71157342, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:09:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.85s\n", + "\u001b[32m2025-05-30 12:09:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.48664522)\n", + "\u001b[32m2025-05-30 12:09:25\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.201, R2_maskV_-1.0=0.799, CC_maskV_-1.0=0.894\n", + "\u001b[32m2025-05-30 12:09:25\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.451, R2_maskV_-1.0=0.488, CC_maskV_-1.0=0.742\n", + "\u001b[32m2025-05-30 12:09:25\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:09:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:10:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 184 (stopped at 199 epochs).\n", + "\u001b[32m2025-05-30 12:10:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/200 - loss=1.1099792, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.12081441, MSE_maskV_-1.0=1.1099228, val_loss=0.9963724, val_CC_maskV_-1.0=0.18795107, val_MSE_maskV_-1.0=0.99510604, learning_rate=0.001\n", + "Epoch 21/200 - loss=0.8077243, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44035855, MSE_maskV_-1.0=0.80792087, val_loss=0.84704292, val_CC_maskV_-1.0=0.42448261, val_MSE_maskV_-1.0=0.84395838, learning_rate=0.001\n", + "Epoch 41/200 - loss=0.76711589, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48396, MSE_maskV_-1.0=0.77121472, val_loss=0.81159675, val_CC_maskV_-1.0=0.46041381, val_MSE_maskV_-1.0=0.80897117, learning_rate=0.001\n", + "Epoch 61/200 - loss=0.74717724, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5040009, MSE_maskV_-1.0=0.74775362, val_loss=0.79458833, val_CC_maskV_-1.0=0.47587377, val_MSE_maskV_-1.0=0.79230064, learning_rate=0.001\n", + "Epoch 81/200 - loss=0.73536968, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51455462, MSE_maskV_-1.0=0.73583937, val_loss=0.77715814, val_CC_maskV_-1.0=0.48975077, val_MSE_maskV_-1.0=0.77553296, learning_rate=0.001\n", + "Epoch 101/200 - loss=0.7264114, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52339596, MSE_maskV_-1.0=0.72570312, val_loss=0.77591479, val_CC_maskV_-1.0=0.49144712, val_MSE_maskV_-1.0=0.77357781, learning_rate=0.001\n", + "Epoch 121/200 - loss=0.72061431, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52847522, MSE_maskV_-1.0=0.72076327, val_loss=0.76665324, val_CC_maskV_-1.0=0.50019324, val_MSE_maskV_-1.0=0.76373029, learning_rate=0.001\n", + "Epoch 141/200 - loss=0.7167967, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53245616, MSE_maskV_-1.0=0.7160362, val_loss=0.76333427, val_CC_maskV_-1.0=0.5029, val_MSE_maskV_-1.0=0.76062691, learning_rate=0.001\n", + "Epoch 161/200 - loss=0.71194196, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53656334, MSE_maskV_-1.0=0.71189302, val_loss=0.75858915, val_CC_maskV_-1.0=0.50720042, val_MSE_maskV_-1.0=0.7555334, learning_rate=0.001\n", + "Epoch 181/200 - loss=0.70916533, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53914285, MSE_maskV_-1.0=0.70966655, val_loss=0.76248115, val_CC_maskV_-1.0=0.50418687, val_MSE_maskV_-1.0=0.75917202, learning_rate=0.001\n", + "Epoch 200/200 - loss=0.70740116, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54052126, MSE_maskV_-1.0=0.70798886, val_loss=0.76078498, val_CC_maskV_-1.0=0.50377846, val_MSE_maskV_-1.0=0.75863415, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:10:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 52.83s\n", + "\u001b[32m2025-05-30 12:10:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:11:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 184 (stopped at 199 epochs).\n", + "\u001b[32m2025-05-30 12:11:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/200 - loss=1.0853864, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.12458348, MSE_maskV_-1.0=1.085339, val_loss=0.99228084, val_CC_maskV_-1.0=0.19762038, val_MSE_maskV_-1.0=0.99048346, learning_rate=0.001\n", + "Epoch 21/200 - loss=0.80839533, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43965223, MSE_maskV_-1.0=0.8086074, val_loss=0.84424549, val_CC_maskV_-1.0=0.42835233, val_MSE_maskV_-1.0=0.84137523, learning_rate=0.001\n", + "Epoch 41/200 - loss=0.76836067, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48238099, MSE_maskV_-1.0=0.77249777, val_loss=0.80501384, val_CC_maskV_-1.0=0.46821475, val_MSE_maskV_-1.0=0.80200553, learning_rate=0.001\n", + "Epoch 61/200 - loss=0.74834305, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50289685, MSE_maskV_-1.0=0.74881184, val_loss=0.79063046, val_CC_maskV_-1.0=0.48116142, val_MSE_maskV_-1.0=0.78719324, learning_rate=0.001\n", + "Epoch 81/200 - loss=0.73676258, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51325953, MSE_maskV_-1.0=0.73722351, val_loss=0.77471173, val_CC_maskV_-1.0=0.49378428, val_MSE_maskV_-1.0=0.77219546, learning_rate=0.001\n", + "Epoch 101/200 - loss=0.72760105, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52225846, MSE_maskV_-1.0=0.7268858, val_loss=0.7725063, val_CC_maskV_-1.0=0.49556854, val_MSE_maskV_-1.0=0.76991194, learning_rate=0.001\n", + "Epoch 121/200 - loss=0.72175008, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5273217, MSE_maskV_-1.0=0.72187704, val_loss=0.76401341, val_CC_maskV_-1.0=0.50282437, val_MSE_maskV_-1.0=0.76133913, learning_rate=0.001\n", + "Epoch 141/200 - loss=0.71820217, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53106999, MSE_maskV_-1.0=0.71752954, val_loss=0.76246512, val_CC_maskV_-1.0=0.50414157, val_MSE_maskV_-1.0=0.75976992, learning_rate=0.001\n", + "Epoch 161/200 - loss=0.7130425, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53554535, MSE_maskV_-1.0=0.71301419, val_loss=0.75888634, val_CC_maskV_-1.0=0.50623888, val_MSE_maskV_-1.0=0.75647062, learning_rate=0.001\n", + "Epoch 181/200 - loss=0.71081275, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53767651, MSE_maskV_-1.0=0.71138388, val_loss=0.76030749, val_CC_maskV_-1.0=0.50654984, val_MSE_maskV_-1.0=0.75727868, learning_rate=0.001\n", + "Epoch 200/200 - loss=0.70839894, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53983229, MSE_maskV_-1.0=0.70904487, val_loss=0.75848448, val_CC_maskV_-1.0=0.50562, val_MSE_maskV_-1.0=0.75629926, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:11:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 52.71s\n", + "\u001b[32m2025-05-30 12:11:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.755431)\n", + "\u001b[32m2025-05-30 12:11:11\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 828us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:11:11\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.704, R2_maskV_-1.0=0.296, CC_maskV_-1.0=0.544\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 829us/step\n", + "51/51 [==============================] - 0s 847us/step\n", + "84/84 [==============================] - 0s 787us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:11:12\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_KCy1HL64U_ErSV16\" (10/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_KCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:11:12\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_CzCy1HL64U_ErSV16\" (11/16)\n", + "\u001b[32m2025-05-30 12:11:12\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_CzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:11:12\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:11:12\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:11:12\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:11:12\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:11:12\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:11:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:11:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 154 (stopped at 169 epochs).\n", + "\u001b[32m2025-05-30 12:11:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/170 - loss=rnn_1step_loss=1.0018306, rnn_1step_R2_maskV_-1.0=-0.013147846, rnn_1step_CC_maskV_-1.0=0.099334754, rnn_1step_MSE_maskV_-1.0=1.0018307, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91733932, val_rnn_1step_R2_maskV_-1.0=-0.059488088, val_rnn_1step_CC_maskV_-1.0=0.23687516, learning_rate=0.001\n", + "Epoch 18/170 - loss=rnn_1step_loss=0.70610189, rnn_1step_R2_maskV_-1.0=0.27901226, rnn_1step_CC_maskV_-1.0=0.54209381, rnn_1step_MSE_maskV_-1.0=0.70610183, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6897071, val_rnn_1step_R2_maskV_-1.0=0.19852906, val_rnn_1step_CC_maskV_-1.0=0.50988895, learning_rate=0.001\n", + "Epoch 35/170 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.5444234, rnn_1step_R2_maskV_-1.0=0.44190037, rnn_1step_CC_maskV_-1.0=0.67500967, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61078316, val_rnn_1step_R2_maskV_-1.0=0.29218671, val_rnn_1step_CC_maskV_-1.0=0.5945217, learning_rate=0.001\n", + "Epoch 52/170 - loss=rnn_1step_loss=0.46601543, rnn_1step_R2_maskV_-1.0=0.52074891, rnn_1step_CC_maskV_-1.0=0.7304551, rnn_1step_MSE_maskV_-1.0=0.4660154, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5843733, val_rnn_1step_R2_maskV_-1.0=0.32207674, val_rnn_1step_CC_maskV_-1.0=0.6312753, learning_rate=0.001\n", + "Epoch 69/170 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41824341, rnn_1step_R2_maskV_-1.0=0.56974745, rnn_1step_CC_maskV_-1.0=0.76259941, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57130831, val_rnn_1step_R2_maskV_-1.0=0.33538294, val_rnn_1step_CC_maskV_-1.0=0.64737219, learning_rate=0.001\n", + "Epoch 86/170 - loss=rnn_1step_loss=0.39806482, rnn_1step_R2_maskV_-1.0=0.59038675, rnn_1step_CC_maskV_-1.0=0.77567625, rnn_1step_MSE_maskV_-1.0=0.39806479, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56233263, val_rnn_1step_R2_maskV_-1.0=0.34579939, val_rnn_1step_CC_maskV_-1.0=0.65424097, learning_rate=0.001\n", + "Epoch 103/170 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37949407, rnn_1step_R2_maskV_-1.0=0.60940886, rnn_1step_CC_maskV_-1.0=0.78750789, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54623574, val_rnn_1step_R2_maskV_-1.0=0.36518556, val_rnn_1step_CC_maskV_-1.0=0.66534126, learning_rate=0.001\n", + "Epoch 120/170 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35764527, rnn_1step_R2_maskV_-1.0=0.63160831, rnn_1step_CC_maskV_-1.0=0.80118281, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5294525, val_rnn_1step_R2_maskV_-1.0=0.38585669, val_rnn_1step_CC_maskV_-1.0=0.67853743, learning_rate=0.001\n", + "Epoch 137/170 - loss=rnn_1step_loss=0.34244609, rnn_1step_R2_maskV_-1.0=0.64680165, rnn_1step_CC_maskV_-1.0=0.81058085, rnn_1step_MSE_maskV_-1.0=0.34244606, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5200119, val_rnn_1step_R2_maskV_-1.0=0.39732021, val_rnn_1step_CC_maskV_-1.0=0.68887156, learning_rate=0.001\n", + "Epoch 154/170 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33434188, rnn_1step_R2_maskV_-1.0=0.65492058, rnn_1step_CC_maskV_-1.0=0.81558615, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51858634, val_rnn_1step_R2_maskV_-1.0=0.39886236, val_rnn_1step_CC_maskV_-1.0=0.69305301, learning_rate=0.001\n", + "Epoch 170/170 - loss=rnn_1step_loss=0.32900003, rnn_1step_R2_maskV_-1.0=0.6602788, rnn_1step_CC_maskV_-1.0=0.8188476, rnn_1step_MSE_maskV_-1.0=0.329, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51864737, val_rnn_1step_R2_maskV_-1.0=0.39873177, val_rnn_1step_CC_maskV_-1.0=0.69514489, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:11:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 19.30s\n", + "\u001b[32m2025-05-30 12:11:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:11:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 39 (stopped at 54 epochs).\n", + "\u001b[32m2025-05-30 12:11:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/55 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0017099, rnn_1_1step_R2_maskV_-1.0=-0.01302832, rnn_1_1step_CC_maskV_-1.0=0.083327323, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91636151, val_rnn_1_1step_R2_maskV_-1.0=-0.058337688, val_rnn_1_1step_CC_maskV_-1.0=0.24520852, learning_rate=0.001\n", + "Epoch 7/55 - loss=rnn_1_1step_loss=0.95789069, rnn_1_1step_R2_maskV_-1.0=0.031447772, rnn_1_1step_CC_maskV_-1.0=0.37539911, rnn_1_1step_MSE_maskV_-1.0=0.95789063, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.86577028, val_rnn_1_1step_R2_maskV_-1.0=-0.00061658025, val_rnn_1_1step_CC_maskV_-1.0=0.36698863, learning_rate=0.001\n", + "Epoch 13/55 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.79646796, rnn_1_1step_R2_maskV_-1.0=0.19203927, rnn_1_1step_CC_maskV_-1.0=0.45578939, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.72524589, val_rnn_1_1step_R2_maskV_-1.0=0.15768874, val_rnn_1_1step_CC_maskV_-1.0=0.4719196, learning_rate=0.001\n", + "Epoch 19/55 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.65115374, rnn_1_1step_R2_maskV_-1.0=0.33512229, rnn_1_1step_CC_maskV_-1.0=0.59138346, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64110416, val_rnn_1_1step_R2_maskV_-1.0=0.25450906, val_rnn_1_1step_CC_maskV_-1.0=0.55394238, learning_rate=0.001\n", + "Epoch 25/55 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.56289148, rnn_1_1step_R2_maskV_-1.0=0.42438287, rnn_1_1step_CC_maskV_-1.0=0.66130304, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59627253, val_rnn_1_1step_R2_maskV_-1.0=0.30775595, val_rnn_1_1step_CC_maskV_-1.0=0.59931713, learning_rate=0.001\n", + "Epoch 31/55 - loss=rnn_1_1step_loss=0.52044612, rnn_1_1step_R2_maskV_-1.0=0.4665527, rnn_1_1step_CC_maskV_-1.0=0.69182193, rnn_1_1step_MSE_maskV_-1.0=0.52044606, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59223121, val_rnn_1_1step_R2_maskV_-1.0=0.31265205, val_rnn_1_1step_CC_maskV_-1.0=0.61233348, learning_rate=0.001\n", + "Epoch 37/55 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.49195945, rnn_1_1step_R2_maskV_-1.0=0.49558765, rnn_1_1step_CC_maskV_-1.0=0.71221054, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5832212, val_rnn_1_1step_R2_maskV_-1.0=0.32314771, val_rnn_1_1step_CC_maskV_-1.0=0.6231994, learning_rate=0.001\n", + "Epoch 43/55 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.46862158, rnn_1_1step_R2_maskV_-1.0=0.51929939, rnn_1_1step_CC_maskV_-1.0=0.72830951, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58379692, val_rnn_1_1step_R2_maskV_-1.0=0.32221001, val_rnn_1_1step_CC_maskV_-1.0=0.62863225, learning_rate=0.001\n", + "Epoch 49/55 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44986168, rnn_1_1step_R2_maskV_-1.0=0.5382508, rnn_1_1step_CC_maskV_-1.0=0.74098754, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58560854, val_rnn_1_1step_R2_maskV_-1.0=0.31969297, val_rnn_1_1step_CC_maskV_-1.0=0.63225794, learning_rate=0.001\n", + "Epoch 55/55 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.43665776, rnn_1_1step_R2_maskV_-1.0=0.55162632, rnn_1_1step_CC_maskV_-1.0=0.74987662, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5842464, val_rnn_1_1step_R2_maskV_-1.0=0.3209514, val_rnn_1_1step_CC_maskV_-1.0=0.63618207, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:11:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 7.18s\n", + "\u001b[32m2025-05-30 12:11:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.51858634)\n", + "\u001b[32m2025-05-30 12:11:40\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.3, R2_maskV_-1.0=0.7, CC_maskV_-1.0=0.837\n", + "\u001b[32m2025-05-30 12:11:40\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.479, R2_maskV_-1.0=0.457, CC_maskV_-1.0=0.723\n", + "\u001b[32m2025-05-30 12:11:40\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:11:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:12:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 89 (stopped at 104 epochs).\n", + "\u001b[32m2025-05-30 12:12:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/105 - loss=1.5522711, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.10696009, MSE_maskV_-1.0=1.5507195, val_loss=1.0052836, val_CC_maskV_-1.0=0.2273453, val_MSE_maskV_-1.0=1.0016301, learning_rate=0.001\n", + "Epoch 12/105 - loss=0.74549496, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50453359, MSE_maskV_-1.0=0.74599975, val_loss=0.78500509, val_CC_maskV_-1.0=0.48541668, val_MSE_maskV_-1.0=0.78276801, learning_rate=0.001\n", + "Epoch 23/105 - loss=0.68417996, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56158751, MSE_maskV_-1.0=0.68363249, val_loss=0.72230595, val_CC_maskV_-1.0=0.5446434, val_MSE_maskV_-1.0=0.71998924, learning_rate=0.001\n", + "Epoch 34/105 - loss=0.65772396, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5839622, MSE_maskV_-1.0=0.657314, val_loss=0.6990205, val_CC_maskV_-1.0=0.56541646, val_MSE_maskV_-1.0=0.69627851, learning_rate=0.001\n", + "Epoch 45/105 - loss=0.64556134, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5942362, MSE_maskV_-1.0=0.64565682, val_loss=0.69015282, val_CC_maskV_-1.0=0.57233739, val_MSE_maskV_-1.0=0.68741071, learning_rate=0.001\n", + "Epoch 56/105 - loss=0.63567126, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60198259, MSE_maskV_-1.0=0.63569534, val_loss=0.68370104, val_CC_maskV_-1.0=0.57778275, val_MSE_maskV_-1.0=0.68064702, learning_rate=0.001\n", + "Epoch 67/105 - loss=0.63016605, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60682338, MSE_maskV_-1.0=0.63008779, val_loss=0.67768812, val_CC_maskV_-1.0=0.58212537, val_MSE_maskV_-1.0=0.6741606, learning_rate=0.001\n", + "Epoch 78/105 - loss=0.62645096, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60933834, MSE_maskV_-1.0=0.62641591, val_loss=0.67354172, val_CC_maskV_-1.0=0.58583254, val_MSE_maskV_-1.0=0.67048848, learning_rate=0.001\n", + "Epoch 89/105 - loss=0.62254745, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61194468, MSE_maskV_-1.0=0.62194836, val_loss=0.6709671, val_CC_maskV_-1.0=0.58735138, val_MSE_maskV_-1.0=0.66787535, learning_rate=0.001\n", + "Epoch 100/105 - loss=0.61945033, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61446553, MSE_maskV_-1.0=0.61975724, val_loss=0.67283392, val_CC_maskV_-1.0=0.58575606, val_MSE_maskV_-1.0=0.66953659, learning_rate=0.001\n", + "Epoch 105/105 - loss=0.61884159, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61695355, MSE_maskV_-1.0=0.61896718, val_loss=0.6716097, val_CC_maskV_-1.0=0.58659649, val_MSE_maskV_-1.0=0.66858888, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:12:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 27.84s\n", + "\u001b[32m2025-05-30 12:12:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:12:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 121 (stopped at 136 epochs).\n", + "\u001b[32m2025-05-30 12:12:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/137 - loss=1.6410669, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.11930119, MSE_maskV_-1.0=1.6394013, val_loss=1.0214728, val_CC_maskV_-1.0=0.21479848, val_MSE_maskV_-1.0=1.0202488, learning_rate=0.001\n", + "Epoch 15/137 - loss=0.7340005, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51537442, MSE_maskV_-1.0=0.73333848, val_loss=0.76525873, val_CC_maskV_-1.0=0.50394046, val_MSE_maskV_-1.0=0.76333731, learning_rate=0.001\n", + "Epoch 29/137 - loss=0.67510664, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56908029, MSE_maskV_-1.0=0.67452967, val_loss=0.70617318, val_CC_maskV_-1.0=0.55707645, val_MSE_maskV_-1.0=0.70416194, learning_rate=0.001\n", + "Epoch 43/137 - loss=0.65022677, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58977127, MSE_maskV_-1.0=0.65000278, val_loss=0.68717849, val_CC_maskV_-1.0=0.57465839, val_MSE_maskV_-1.0=0.68448108, learning_rate=0.001\n", + "Epoch 57/137 - loss=0.63816524, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60066009, MSE_maskV_-1.0=0.63842559, val_loss=0.67676717, val_CC_maskV_-1.0=0.58304679, val_MSE_maskV_-1.0=0.67405182, learning_rate=0.001\n", + "Epoch 71/137 - loss=0.63105392, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60582078, MSE_maskV_-1.0=0.63123894, val_loss=0.67473608, val_CC_maskV_-1.0=0.58392394, val_MSE_maskV_-1.0=0.67218077, learning_rate=0.001\n", + "Epoch 85/137 - loss=0.62425542, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61159688, MSE_maskV_-1.0=0.62442303, val_loss=0.67300963, val_CC_maskV_-1.0=0.58643293, val_MSE_maskV_-1.0=0.6702435, learning_rate=0.001\n", + "Epoch 99/137 - loss=0.61998892, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61435181, MSE_maskV_-1.0=0.61964494, val_loss=0.67196035, val_CC_maskV_-1.0=0.58733171, val_MSE_maskV_-1.0=0.66896242, learning_rate=0.001\n", + "Epoch 113/137 - loss=0.61576414, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61809933, MSE_maskV_-1.0=0.617818, val_loss=0.67313409, val_CC_maskV_-1.0=0.58694255, val_MSE_maskV_-1.0=0.67040521, learning_rate=0.001\n", + "Epoch 127/137 - loss=0.61404169, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61971039, MSE_maskV_-1.0=0.61418533, val_loss=0.66640705, val_CC_maskV_-1.0=0.59107053, val_MSE_maskV_-1.0=0.66366982, learning_rate=0.001\n", + "Epoch 137/137 - loss=0.61232865, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62008828, MSE_maskV_-1.0=0.61236238, val_loss=0.66882122, val_CC_maskV_-1.0=0.58942145, val_MSE_maskV_-1.0=0.66634399, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:12:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 36.44s\n", + "\u001b[32m2025-05-30 12:12:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.6639514)\n", + "\u001b[32m2025-05-30 12:12:45\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 795us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:12:45\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.61, R2_maskV_-1.0=0.392, CC_maskV_-1.0=0.625\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 853us/step\n", + "51/51 [==============================] - 0s 791us/step\n", + "84/84 [==============================] - 0s 719us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:12:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_CzCy1HL64U_ErSV16\" (11/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_CzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:12:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_uAKCz1HL64U_ErSV16\" (12/16)\n", + "\u001b[32m2025-05-30 12:12:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:12:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:12:46\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:12:46\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:12:46\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:12:46\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:12:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:13:01\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 99 (stopped at 114 epochs).\n", + "\u001b[32m2025-05-30 12:13:01\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0023397, rnn_1step_R2_maskV_-1.0=-0.013657372, rnn_1step_CC_maskV_-1.0=0.030326225, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91788673, val_rnn_1step_R2_maskV_-1.0=-0.060094535, val_rnn_1step_CC_maskV_-1.0=0.25486827, learning_rate=0.001\n", + "Epoch 13/115 - loss=rnn_1step_loss=0.83273238, rnn_1step_R2_maskV_-1.0=0.15467437, rnn_1step_CC_maskV_-1.0=0.41217673, rnn_1step_MSE_maskV_-1.0=0.83273244, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.77031237, val_rnn_1step_R2_maskV_-1.0=0.10998903, val_rnn_1step_CC_maskV_-1.0=0.41331738, learning_rate=0.001\n", + "Epoch 25/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.581182, rnn_1step_R2_maskV_-1.0=0.40407997, rnn_1step_CC_maskV_-1.0=0.64847827, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60939163, val_rnn_1step_R2_maskV_-1.0=0.29201394, val_rnn_1step_CC_maskV_-1.0=0.58155477, learning_rate=0.001\n", + "Epoch 37/115 - loss=rnn_1step_loss=0.47510961, rnn_1step_R2_maskV_-1.0=0.51091522, rnn_1step_CC_maskV_-1.0=0.72430032, rnn_1step_MSE_maskV_-1.0=0.47510958, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59443027, val_rnn_1step_R2_maskV_-1.0=0.30819774, val_rnn_1step_CC_maskV_-1.0=0.60942292, learning_rate=0.001\n", + "Epoch 49/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42111912, rnn_1step_R2_maskV_-1.0=0.56578428, rnn_1step_CC_maskV_-1.0=0.7611444, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58372271, val_rnn_1step_R2_maskV_-1.0=0.3206546, val_rnn_1step_CC_maskV_-1.0=0.62906057, learning_rate=0.001\n", + "Epoch 61/115 - loss=rnn_1step_loss=0.37220573, rnn_1step_R2_maskV_-1.0=0.61566114, rnn_1step_CC_maskV_-1.0=0.79268509, rnn_1step_MSE_maskV_-1.0=0.37220576, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54394746, val_rnn_1step_R2_maskV_-1.0=0.3678332, val_rnn_1step_CC_maskV_-1.0=0.66135514, learning_rate=0.001\n", + "Epoch 73/115 - loss=rnn_1step_loss=0.34557179, rnn_1step_R2_maskV_-1.0=0.6420275, rnn_1step_CC_maskV_-1.0=0.80941939, rnn_1step_MSE_maskV_-1.0=0.34557182, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5493024, val_rnn_1step_R2_maskV_-1.0=0.3608458, val_rnn_1step_CC_maskV_-1.0=0.6661126, learning_rate=0.001\n", + "Epoch 85/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32263607, rnn_1step_R2_maskV_-1.0=0.66543943, rnn_1step_CC_maskV_-1.0=0.82345825, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54246783, val_rnn_1step_R2_maskV_-1.0=0.36919713, val_rnn_1step_CC_maskV_-1.0=0.67215014, learning_rate=0.001\n", + "Epoch 97/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30653509, rnn_1step_R2_maskV_-1.0=0.68278086, rnn_1step_CC_maskV_-1.0=0.83281487, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53531456, val_rnn_1step_R2_maskV_-1.0=0.37795568, val_rnn_1step_CC_maskV_-1.0=0.67870426, learning_rate=0.001\n", + "Epoch 109/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.28760484, rnn_1step_R2_maskV_-1.0=0.70161355, rnn_1step_CC_maskV_-1.0=0.84489441, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51774192, val_rnn_1step_R2_maskV_-1.0=0.39855182, val_rnn_1step_CC_maskV_-1.0=0.68587178, learning_rate=0.001\n", + "Epoch 115/115 - loss=rnn_1step_loss=0.27606842, rnn_1step_R2_maskV_-1.0=0.71383548, rnn_1step_CC_maskV_-1.0=0.85106671, rnn_1step_MSE_maskV_-1.0=0.27606839, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53077674, val_rnn_1step_R2_maskV_-1.0=0.38305444, val_rnn_1step_CC_maskV_-1.0=0.68079215, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:13:01\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.72s\n", + "\u001b[32m2025-05-30 12:13:01\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:13:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 106 (stopped at 121 epochs).\n", + "\u001b[32m2025-05-30 12:13:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/122 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0023743, rnn_1_1step_R2_maskV_-1.0=-0.01370237, rnn_1_1step_CC_maskV_-1.0=0.023166046, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91800541, val_rnn_1_1step_R2_maskV_-1.0=-0.060246482, val_rnn_1_1step_CC_maskV_-1.0=0.30883014, learning_rate=0.001\n", + "Epoch 14/122 - loss=rnn_1_1step_loss=0.81515104, rnn_1_1step_R2_maskV_-1.0=0.1735526, rnn_1_1step_CC_maskV_-1.0=0.43487614, rnn_1_1step_MSE_maskV_-1.0=0.8151511, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.76351041, val_rnn_1_1step_R2_maskV_-1.0=0.113185, val_rnn_1_1step_CC_maskV_-1.0=0.41081756, learning_rate=0.001\n", + "Epoch 27/122 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.59807634, rnn_1_1step_R2_maskV_-1.0=0.38877517, rnn_1_1step_CC_maskV_-1.0=0.63399267, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.66908628, val_rnn_1_1step_R2_maskV_-1.0=0.22368318, val_rnn_1_1step_CC_maskV_-1.0=0.53449452, learning_rate=0.001\n", + "Epoch 40/122 - loss=rnn_1_1step_loss=0.4512949, rnn_1_1step_R2_maskV_-1.0=0.53587842, rnn_1_1step_CC_maskV_-1.0=0.74049383, rnn_1_1step_MSE_maskV_-1.0=0.45129487, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5990783, val_rnn_1_1step_R2_maskV_-1.0=0.30501759, val_rnn_1_1step_CC_maskV_-1.0=0.60772175, learning_rate=0.001\n", + "Epoch 53/122 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.37350738, rnn_1_1step_R2_maskV_-1.0=0.61517942, rnn_1_1step_CC_maskV_-1.0=0.79131347, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59970337, val_rnn_1_1step_R2_maskV_-1.0=0.30417794, val_rnn_1_1step_CC_maskV_-1.0=0.62244374, learning_rate=0.001\n", + "Epoch 66/122 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33386591, rnn_1_1step_R2_maskV_-1.0=0.65555024, rnn_1_1step_CC_maskV_-1.0=0.81631863, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58578926, val_rnn_1_1step_R2_maskV_-1.0=0.32007152, val_rnn_1_1step_CC_maskV_-1.0=0.6445688, learning_rate=0.001\n", + "Epoch 79/122 - loss=rnn_1_1step_loss=0.30318406, rnn_1_1step_R2_maskV_-1.0=0.6869874, rnn_1_1step_CC_maskV_-1.0=0.83532268, rnn_1_1step_MSE_maskV_-1.0=0.30318403, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55411911, val_rnn_1_1step_R2_maskV_-1.0=0.35775656, val_rnn_1_1step_CC_maskV_-1.0=0.66112596, learning_rate=0.001\n", + "Epoch 92/122 - loss=rnn_1_1step_loss=0.27432188, rnn_1_1step_R2_maskV_-1.0=0.71708244, rnn_1_1step_CC_maskV_-1.0=0.85241151, rnn_1_1step_MSE_maskV_-1.0=0.27432191, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52654165, val_rnn_1_1step_R2_maskV_-1.0=0.3905676, val_rnn_1_1step_CC_maskV_-1.0=0.67819983, learning_rate=0.001\n", + "Epoch 105/122 - loss=rnn_1_1step_loss=0.26886576, rnn_1_1step_R2_maskV_-1.0=0.72226322, rnn_1_1step_CC_maskV_-1.0=0.85623068, rnn_1_1step_MSE_maskV_-1.0=0.26886573, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55840111, val_rnn_1_1step_R2_maskV_-1.0=0.35273969, val_rnn_1_1step_CC_maskV_-1.0=0.67124319, learning_rate=0.001\n", + "Epoch 118/122 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.23678719, rnn_1_1step_R2_maskV_-1.0=0.75511837, rnn_1_1step_CC_maskV_-1.0=0.8742727, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52602077, val_rnn_1_1step_R2_maskV_-1.0=0.39110482, val_rnn_1_1step_CC_maskV_-1.0=0.68837249, learning_rate=0.001\n", + "Epoch 122/122 - loss=rnn_1_1step_loss=0.24703671, rnn_1_1step_R2_maskV_-1.0=0.74488658, rnn_1_1step_CC_maskV_-1.0=0.86967409, rnn_1_1step_MSE_maskV_-1.0=0.2470367, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51046413, val_rnn_1_1step_R2_maskV_-1.0=0.40960354, val_rnn_1_1step_CC_maskV_-1.0=0.69182169, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:13:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 16.17s\n", + "\u001b[32m2025-05-30 12:13:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.5067212)\n", + "\u001b[32m2025-05-30 12:13:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.241, R2_maskV_-1.0=0.758, CC_maskV_-1.0=0.874\n", + "\u001b[32m2025-05-30 12:13:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.468, R2_maskV_-1.0=0.472, CC_maskV_-1.0=0.718\n", + "\u001b[32m2025-05-30 12:13:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:13:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:14:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 313 (stopped at 328 epochs).\n", + "\u001b[32m2025-05-30 12:14:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/329 - loss=2.2744682, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.027656538, MSE_maskV_-1.0=2.2712088, val_loss=1.140025, val_CC_maskV_-1.0=0.07601878, val_MSE_maskV_-1.0=1.1406595, learning_rate=0.001\n", + "Epoch 34/329 - loss=0.88245034, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34943971, MSE_maskV_-1.0=0.88180572, val_loss=0.9086802, val_CC_maskV_-1.0=0.35073629, val_MSE_maskV_-1.0=0.90551299, learning_rate=0.001\n", + "Epoch 67/329 - loss=0.85524267, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38672745, MSE_maskV_-1.0=0.85496598, val_loss=0.88259131, val_CC_maskV_-1.0=0.38515997, val_MSE_maskV_-1.0=0.87925255, learning_rate=0.001\n", + "Epoch 100/329 - loss=0.8399477, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40510535, MSE_maskV_-1.0=0.84006256, val_loss=0.86866742, val_CC_maskV_-1.0=0.40037394, val_MSE_maskV_-1.0=0.86576486, learning_rate=0.001\n", + "Epoch 133/329 - loss=0.83013278, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41649961, MSE_maskV_-1.0=0.82985526, val_loss=0.85695827, val_CC_maskV_-1.0=0.41324729, val_MSE_maskV_-1.0=0.85395461, learning_rate=0.001\n", + "Epoch 166/329 - loss=0.8231613, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4247466, MSE_maskV_-1.0=0.8234219, val_loss=0.84852892, val_CC_maskV_-1.0=0.42061067, val_MSE_maskV_-1.0=0.84611577, learning_rate=0.001\n", + "Epoch 199/329 - loss=0.81797057, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42943117, MSE_maskV_-1.0=0.81787664, val_loss=0.84762955, val_CC_maskV_-1.0=0.42084137, val_MSE_maskV_-1.0=0.84468132, learning_rate=0.001\n", + "Epoch 232/329 - loss=0.81403691, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43324283, MSE_maskV_-1.0=0.81413704, val_loss=0.83733249, val_CC_maskV_-1.0=0.43164974, val_MSE_maskV_-1.0=0.83513963, learning_rate=0.001\n", + "Epoch 265/329 - loss=0.81129616, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43607867, MSE_maskV_-1.0=0.81135219, val_loss=0.83679336, val_CC_maskV_-1.0=0.43127936, val_MSE_maskV_-1.0=0.83428335, learning_rate=0.001\n", + "Epoch 298/329 - loss=0.80827135, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43956614, MSE_maskV_-1.0=0.80764282, val_loss=0.83245045, val_CC_maskV_-1.0=0.43600416, val_MSE_maskV_-1.0=0.83032703, learning_rate=0.001\n", + "Epoch 329/329 - loss=0.80584627, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44187164, MSE_maskV_-1.0=0.80516392, val_loss=0.83187652, val_CC_maskV_-1.0=0.43579552, val_MSE_maskV_-1.0=0.82983631, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:14:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 80.15s\n", + "\u001b[32m2025-05-30 12:14:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:15:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 313 (stopped at 328 epochs).\n", + "\u001b[32m2025-05-30 12:15:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/329 - loss=2.2461076, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.03881976, MSE_maskV_-1.0=2.2428017, val_loss=1.1048882, val_CC_maskV_-1.0=0.088461854, val_MSE_maskV_-1.0=1.1004927, learning_rate=0.001\n", + "Epoch 34/329 - loss=0.88675517, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34249058, MSE_maskV_-1.0=0.88609946, val_loss=0.9153474, val_CC_maskV_-1.0=0.34084353, val_MSE_maskV_-1.0=0.91169798, learning_rate=0.001\n", + "Epoch 67/329 - loss=0.85855365, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38209075, MSE_maskV_-1.0=0.85826141, val_loss=0.88775706, val_CC_maskV_-1.0=0.37859583, val_MSE_maskV_-1.0=0.88420427, learning_rate=0.001\n", + "Epoch 100/329 - loss=0.84244382, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40196696, MSE_maskV_-1.0=0.84255874, val_loss=0.87297028, val_CC_maskV_-1.0=0.39531931, val_MSE_maskV_-1.0=0.86999005, learning_rate=0.001\n", + "Epoch 133/329 - loss=0.83212262, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41406399, MSE_maskV_-1.0=0.83186543, val_loss=0.86040235, val_CC_maskV_-1.0=0.4095304, val_MSE_maskV_-1.0=0.85733497, learning_rate=0.001\n", + "Epoch 166/329 - loss=0.82477283, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42287135, MSE_maskV_-1.0=0.82503867, val_loss=0.85147369, val_CC_maskV_-1.0=0.41749996, val_MSE_maskV_-1.0=0.84899729, learning_rate=0.001\n", + "Epoch 199/329 - loss=0.81932765, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42788392, MSE_maskV_-1.0=0.81923401, val_loss=0.85007983, val_CC_maskV_-1.0=0.41832757, val_MSE_maskV_-1.0=0.84707087, learning_rate=0.001\n", + "Epoch 232/329 - loss=0.81520706, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43193024, MSE_maskV_-1.0=0.81531197, val_loss=0.8394329, val_CC_maskV_-1.0=0.42961794, val_MSE_maskV_-1.0=0.83716249, learning_rate=0.001\n", + "Epoch 265/329 - loss=0.81232041, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43492588, MSE_maskV_-1.0=0.81237847, val_loss=0.83864832, val_CC_maskV_-1.0=0.42949265, val_MSE_maskV_-1.0=0.83607256, learning_rate=0.001\n", + "Epoch 298/329 - loss=0.80918175, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43859887, MSE_maskV_-1.0=0.80854988, val_loss=0.83424026, val_CC_maskV_-1.0=0.43424383, val_MSE_maskV_-1.0=0.83206326, learning_rate=0.001\n", + "Epoch 329/329 - loss=0.8066532, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44098461, MSE_maskV_-1.0=0.80596954, val_loss=0.83342606, val_CC_maskV_-1.0=0.43428871, val_MSE_maskV_-1.0=0.83134478, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:15:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 80.25s\n", + "\u001b[32m2025-05-30 12:15:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.82976681)\n", + "\u001b[32m2025-05-30 12:15:59\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 754us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:16:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.807, R2_maskV_-1.0=0.194, CC_maskV_-1.0=0.442\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 746us/step\n", + "51/51 [==============================] - 0s 817us/step\n", + "84/84 [==============================] - 0s 718us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:16:00\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_uAKCz1HL64U_ErSV16\" (12/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_uAKCz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:16:00\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_uAKCy1HL64U_ErSV16\" (13/16)\n", + "\u001b[32m2025-05-30 12:16:00\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:16:00\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:16:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:16:01\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:16:01\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:16:01\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:16:01\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:16:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 99 (stopped at 114 epochs).\n", + "\u001b[32m2025-05-30 12:16:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0009238, rnn_1step_R2_maskV_-1.0=-0.012219172, rnn_1step_CC_maskV_-1.0=0.18491623, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91591841, val_rnn_1step_R2_maskV_-1.0=-0.057913721, val_rnn_1step_CC_maskV_-1.0=0.29705656, learning_rate=0.001\n", + "Epoch 13/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.80005413, rnn_1step_R2_maskV_-1.0=0.18721922, rnn_1step_CC_maskV_-1.0=0.45365649, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.75194097, val_rnn_1step_R2_maskV_-1.0=0.1257142, val_rnn_1step_CC_maskV_-1.0=0.42734778, learning_rate=0.001\n", + "Epoch 25/115 - loss=rnn_1step_loss=0.60399348, rnn_1step_R2_maskV_-1.0=0.38110572, rnn_1step_CC_maskV_-1.0=0.63031697, rnn_1step_MSE_maskV_-1.0=0.60399354, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.66780925, val_rnn_1step_R2_maskV_-1.0=0.22358221, val_rnn_1step_CC_maskV_-1.0=0.53801036, learning_rate=0.001\n", + "Epoch 37/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.47902378, rnn_1step_R2_maskV_-1.0=0.50778371, rnn_1step_CC_maskV_-1.0=0.72176957, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60845572, val_rnn_1step_R2_maskV_-1.0=0.29505092, val_rnn_1step_CC_maskV_-1.0=0.59875298, learning_rate=0.001\n", + "Epoch 49/115 - loss=rnn_1step_loss=0.38997054, rnn_1step_R2_maskV_-1.0=0.59751201, rnn_1step_CC_maskV_-1.0=0.78089929, rnn_1step_MSE_maskV_-1.0=0.38997051, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57179564, val_rnn_1step_R2_maskV_-1.0=0.33711398, val_rnn_1step_CC_maskV_-1.0=0.64344823, learning_rate=0.001\n", + "Epoch 61/115 - loss=rnn_1step_loss=0.32200631, rnn_1step_R2_maskV_-1.0=0.66711754, rnn_1step_CC_maskV_-1.0=0.82359767, rnn_1step_MSE_maskV_-1.0=0.32200629, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54506826, val_rnn_1step_R2_maskV_-1.0=0.3678177, val_rnn_1step_CC_maskV_-1.0=0.67163223, learning_rate=0.001\n", + "Epoch 73/115 - loss=rnn_1step_loss=0.27651662, rnn_1step_R2_maskV_-1.0=0.71417212, rnn_1step_CC_maskV_-1.0=0.85081428, rnn_1step_MSE_maskV_-1.0=0.27651659, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52394992, val_rnn_1step_R2_maskV_-1.0=0.39333725, val_rnn_1step_CC_maskV_-1.0=0.68707299, learning_rate=0.001\n", + "Epoch 85/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.25524402, rnn_1step_R2_maskV_-1.0=0.7358135, rnn_1step_CC_maskV_-1.0=0.86343312, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50504404, val_rnn_1step_R2_maskV_-1.0=0.41553646, val_rnn_1step_CC_maskV_-1.0=0.70033783, learning_rate=0.001\n", + "Epoch 97/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.23148638, rnn_1step_R2_maskV_-1.0=0.76071334, rnn_1step_CC_maskV_-1.0=0.87707937, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47792765, val_rnn_1step_R2_maskV_-1.0=0.4466306, val_rnn_1step_CC_maskV_-1.0=0.7144863, learning_rate=0.001\n", + "Epoch 109/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.21322535, rnn_1step_R2_maskV_-1.0=0.7793619, rnn_1step_CC_maskV_-1.0=0.88753694, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51763231, val_rnn_1step_R2_maskV_-1.0=0.40144807, val_rnn_1step_CC_maskV_-1.0=0.70031297, learning_rate=0.001\n", + "Epoch 115/115 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.20523554, rnn_1step_R2_maskV_-1.0=0.78775746, rnn_1step_CC_maskV_-1.0=0.89182001, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51052529, val_rnn_1step_R2_maskV_-1.0=0.4097611, val_rnn_1step_CC_maskV_-1.0=0.7050994, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:16:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.19s\n", + "\u001b[32m2025-05-30 12:16:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:16:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 46 (stopped at 61 epochs).\n", + "\u001b[32m2025-05-30 12:16:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/62 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0017989, rnn_1_1step_R2_maskV_-1.0=-0.013121039, rnn_1_1step_CC_maskV_-1.0=0.083907507, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91758901, val_rnn_1_1step_R2_maskV_-1.0=-0.059762716, val_rnn_1_1step_CC_maskV_-1.0=0.14574994, learning_rate=0.001\n", + "Epoch 8/62 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.94596833, rnn_1_1step_R2_maskV_-1.0=0.043437973, rnn_1_1step_CC_maskV_-1.0=0.43640906, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.86335111, val_rnn_1_1step_R2_maskV_-1.0=0.0031139702, val_rnn_1_1step_CC_maskV_-1.0=0.36240447, learning_rate=0.001\n", + "Epoch 15/62 - loss=rnn_1_1step_loss=0.6922161, rnn_1_1step_R2_maskV_-1.0=0.29119188, rnn_1_1step_CC_maskV_-1.0=0.55699861, rnn_1_1step_MSE_maskV_-1.0=0.69221598, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.68102598, val_rnn_1_1step_R2_maskV_-1.0=0.21151942, val_rnn_1_1step_CC_maskV_-1.0=0.52469683, learning_rate=0.001\n", + "Epoch 22/62 - loss=rnn_1_1step_loss=0.57846516, rnn_1_1step_R2_maskV_-1.0=0.40725619, rnn_1_1step_CC_maskV_-1.0=0.6492368, rnn_1_1step_MSE_maskV_-1.0=0.5784651, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61619812, val_rnn_1_1step_R2_maskV_-1.0=0.28558928, val_rnn_1_1step_CC_maskV_-1.0=0.58248246, learning_rate=0.001\n", + "Epoch 29/62 - loss=rnn_1_1step_loss=0.51731366, rnn_1_1step_R2_maskV_-1.0=0.46776432, rnn_1_1step_CC_maskV_-1.0=0.6946221, rnn_1_1step_MSE_maskV_-1.0=0.5173136, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60838932, val_rnn_1_1step_R2_maskV_-1.0=0.29367313, val_rnn_1_1step_CC_maskV_-1.0=0.59751749, learning_rate=0.001\n", + "Epoch 36/62 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.46621218, rnn_1_1step_R2_maskV_-1.0=0.51984012, rnn_1_1step_CC_maskV_-1.0=0.73035312, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58613902, val_rnn_1_1step_R2_maskV_-1.0=0.31919318, val_rnn_1_1step_CC_maskV_-1.0=0.61885947, learning_rate=0.001\n", + "Epoch 43/62 - loss=rnn_1_1step_loss=0.40792927, rnn_1_1step_R2_maskV_-1.0=0.57993311, rnn_1_1step_CC_maskV_-1.0=0.76917213, rnn_1_1step_MSE_maskV_-1.0=0.40792924, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55597109, val_rnn_1_1step_R2_maskV_-1.0=0.3538419, val_rnn_1_1step_CC_maskV_-1.0=0.64915973, learning_rate=0.001\n", + "Epoch 50/62 - loss=rnn_1_1step_loss=0.36582589, rnn_1_1step_R2_maskV_-1.0=0.62323618, rnn_1_1step_CC_maskV_-1.0=0.79619122, rnn_1_1step_MSE_maskV_-1.0=0.36582586, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55156487, val_rnn_1_1step_R2_maskV_-1.0=0.35836396, val_rnn_1_1step_CC_maskV_-1.0=0.66083473, learning_rate=0.001\n", + "Epoch 57/62 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.34220442, rnn_1_1step_R2_maskV_-1.0=0.64722377, rnn_1_1step_CC_maskV_-1.0=0.8110708, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57291061, val_rnn_1_1step_R2_maskV_-1.0=0.33292845, val_rnn_1_1step_CC_maskV_-1.0=0.6542483, learning_rate=0.001\n", + "Epoch 62/62 - loss=rnn_1_1step_loss=0.32828614, rnn_1_1step_R2_maskV_-1.0=0.66177553, rnn_1_1step_CC_maskV_-1.0=0.81953365, rnn_1_1step_MSE_maskV_-1.0=0.32828617, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56539822, val_rnn_1_1step_R2_maskV_-1.0=0.34176934, val_rnn_1_1step_CC_maskV_-1.0=0.65888512, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:16:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.24s\n", + "\u001b[32m2025-05-30 12:16:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.46459126)\n", + "\u001b[32m2025-05-30 12:16:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.218, R2_maskV_-1.0=0.782, CC_maskV_-1.0=0.886\n", + "\u001b[32m2025-05-30 12:16:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.424, R2_maskV_-1.0=0.521, CC_maskV_-1.0=0.752\n", + "\u001b[32m2025-05-30 12:16:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:16:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:17:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 133 (stopped at 148 epochs).\n", + "\u001b[32m2025-05-30 12:17:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/149 - loss=1.0058343, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.17602156, MSE_maskV_-1.0=1.0060263, val_loss=0.9699136, val_CC_maskV_-1.0=0.24211921, val_MSE_maskV_-1.0=0.96702427, learning_rate=0.001\n", + "Epoch 16/149 - loss=0.80939329, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43793949, MSE_maskV_-1.0=0.8091563, val_loss=0.85468864, val_CC_maskV_-1.0=0.41261077, val_MSE_maskV_-1.0=0.85206872, learning_rate=0.001\n", + "Epoch 31/149 - loss=0.77395463, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47599456, MSE_maskV_-1.0=0.77397764, val_loss=0.82576126, val_CC_maskV_-1.0=0.4408713, val_MSE_maskV_-1.0=0.82394177, learning_rate=0.001\n", + "Epoch 46/149 - loss=0.75674981, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49367428, MSE_maskV_-1.0=0.75772351, val_loss=0.81419671, val_CC_maskV_-1.0=0.45286915, val_MSE_maskV_-1.0=0.81255281, learning_rate=0.001\n", + "Epoch 61/149 - loss=0.74499899, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50570035, MSE_maskV_-1.0=0.74555105, val_loss=0.80449992, val_CC_maskV_-1.0=0.46223679, val_MSE_maskV_-1.0=0.80236942, learning_rate=0.001\n", + "Epoch 76/149 - loss=0.73709697, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51238918, MSE_maskV_-1.0=0.73705143, val_loss=0.79931194, val_CC_maskV_-1.0=0.46688136, val_MSE_maskV_-1.0=0.79754901, learning_rate=0.001\n", + "Epoch 91/149 - loss=0.73065817, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51858252, MSE_maskV_-1.0=0.73116815, val_loss=0.79631984, val_CC_maskV_-1.0=0.47094756, val_MSE_maskV_-1.0=0.79460829, learning_rate=0.001\n", + "Epoch 106/149 - loss=0.72592264, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52319562, MSE_maskV_-1.0=0.72656906, val_loss=0.79333395, val_CC_maskV_-1.0=0.47405869, val_MSE_maskV_-1.0=0.79103446, learning_rate=0.001\n", + "Epoch 121/149 - loss=0.72153407, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52700162, MSE_maskV_-1.0=0.72169864, val_loss=0.78933293, val_CC_maskV_-1.0=0.47763908, val_MSE_maskV_-1.0=0.78648263, learning_rate=0.001\n", + "Epoch 136/149 - loss=0.71874106, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53011149, MSE_maskV_-1.0=0.71914226, val_loss=0.78662139, val_CC_maskV_-1.0=0.47954968, val_MSE_maskV_-1.0=0.78440124, learning_rate=0.001\n", + "Epoch 149/149 - loss=0.71587056, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53216022, MSE_maskV_-1.0=0.71531695, val_loss=0.78858513, val_CC_maskV_-1.0=0.47791246, val_MSE_maskV_-1.0=0.78593367, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:17:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 39.07s\n", + "\u001b[32m2025-05-30 12:17:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:18:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 220 (stopped at 235 epochs).\n", + "\u001b[32m2025-05-30 12:18:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/236 - loss=1.0103772, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.17266878, MSE_maskV_-1.0=1.0105921, val_loss=0.96767008, val_CC_maskV_-1.0=0.2463498, val_MSE_maskV_-1.0=0.96576917, learning_rate=0.001\n", + "Epoch 25/236 - loss=0.78662521, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46233532, MSE_maskV_-1.0=0.78619194, val_loss=0.84020245, val_CC_maskV_-1.0=0.42716321, val_MSE_maskV_-1.0=0.83749622, learning_rate=0.001\n", + "Epoch 49/236 - loss=0.75325221, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49730423, MSE_maskV_-1.0=0.75315666, val_loss=0.81388539, val_CC_maskV_-1.0=0.45362458, val_MSE_maskV_-1.0=0.81165397, learning_rate=0.001\n", + "Epoch 73/236 - loss=0.73756188, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51130354, MSE_maskV_-1.0=0.73770207, val_loss=0.80440503, val_CC_maskV_-1.0=0.46227035, val_MSE_maskV_-1.0=0.80310994, learning_rate=0.001\n", + "Epoch 97/236 - loss=0.72800505, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52089781, MSE_maskV_-1.0=0.72856373, val_loss=0.79423833, val_CC_maskV_-1.0=0.47113883, val_MSE_maskV_-1.0=0.793221, learning_rate=0.001\n", + "Epoch 121/236 - loss=0.72096521, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52753985, MSE_maskV_-1.0=0.72113431, val_loss=0.78862113, val_CC_maskV_-1.0=0.47757804, val_MSE_maskV_-1.0=0.78695679, learning_rate=0.001\n", + "Epoch 145/236 - loss=0.71566188, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53167856, MSE_maskV_-1.0=0.71521199, val_loss=0.78717953, val_CC_maskV_-1.0=0.47837773, val_MSE_maskV_-1.0=0.7858699, learning_rate=0.001\n", + "Epoch 169/236 - loss=0.71147436, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53624272, MSE_maskV_-1.0=0.71121097, val_loss=0.7852537, val_CC_maskV_-1.0=0.48143294, val_MSE_maskV_-1.0=0.78394377, learning_rate=0.001\n", + "Epoch 193/236 - loss=0.70733398, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54030252, MSE_maskV_-1.0=0.70733672, val_loss=0.78267342, val_CC_maskV_-1.0=0.48384714, val_MSE_maskV_-1.0=0.78123474, learning_rate=0.001\n", + "Epoch 217/236 - loss=0.70450193, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54262555, MSE_maskV_-1.0=0.70389855, val_loss=0.77783579, val_CC_maskV_-1.0=0.48814124, val_MSE_maskV_-1.0=0.77641541, learning_rate=0.001\n", + "Epoch 236/236 - loss=0.70246655, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54380918, MSE_maskV_-1.0=0.70255572, val_loss=0.77762306, val_CC_maskV_-1.0=0.48796481, val_MSE_maskV_-1.0=0.77644497, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:18:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 63.09s\n", + "\u001b[32m2025-05-30 12:18:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.77522868)\n", + "\u001b[32m2025-05-30 12:18:11\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 795us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:18:11\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.7, R2_maskV_-1.0=0.301, CC_maskV_-1.0=0.548\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 798us/step\n", + "51/51 [==============================] - 0s 1ms/step\n", + "84/84 [==============================] - 0s 737us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:18:12\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_uAKCy1HL64U_ErSV16\" (13/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_uAKCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:18:12\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_ACzCy1HL64U_ErSV16\" (14/16)\n", + "\u001b[32m2025-05-30 12:18:12\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:18:12\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:18:12\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:18:13\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:18:13\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:18:13\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:18:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:18:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 103 (stopped at 118 epochs).\n", + "\u001b[32m2025-05-30 12:18:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/119 - loss=rnn_1step_loss=1.0015501, rnn_1step_R2_maskV_-1.0=-0.012873281, rnn_1step_CC_maskV_-1.0=0.09920837, rnn_1step_MSE_maskV_-1.0=1.00155, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91645032, val_rnn_1step_R2_maskV_-1.0=-0.058380574, val_rnn_1step_CC_maskV_-1.0=0.26144996, learning_rate=0.001\n", + "Epoch 13/119 - loss=rnn_1step_loss=0.81966275, rnn_1step_R2_maskV_-1.0=0.16593932, rnn_1step_CC_maskV_-1.0=0.42880839, rnn_1step_MSE_maskV_-1.0=0.81966269, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.76306313, val_rnn_1step_R2_maskV_-1.0=0.11701404, val_rnn_1step_CC_maskV_-1.0=0.41587344, learning_rate=0.001\n", + "Epoch 25/119 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.60740477, rnn_1step_R2_maskV_-1.0=0.37905973, rnn_1step_CC_maskV_-1.0=0.62611729, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64453727, val_rnn_1step_R2_maskV_-1.0=0.25524712, val_rnn_1step_CC_maskV_-1.0=0.55500829, learning_rate=0.001\n", + "Epoch 37/119 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.52030683, rnn_1step_R2_maskV_-1.0=0.46704522, rnn_1step_CC_maskV_-1.0=0.69248474, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62440139, val_rnn_1step_R2_maskV_-1.0=0.27751303, val_rnn_1step_CC_maskV_-1.0=0.58934081, learning_rate=0.001\n", + "Epoch 49/119 - loss=rnn_1step_loss=0.48513389, rnn_1step_R2_maskV_-1.0=0.50218576, rnn_1step_CC_maskV_-1.0=0.71734828, rnn_1step_MSE_maskV_-1.0=0.48513392, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61451536, val_rnn_1step_R2_maskV_-1.0=0.28872019, val_rnn_1step_CC_maskV_-1.0=0.60210693, learning_rate=0.001\n", + "Epoch 61/119 - loss=rnn_1step_loss=0.45911017, rnn_1step_R2_maskV_-1.0=0.52818286, rnn_1step_CC_maskV_-1.0=0.73518205, rnn_1step_MSE_maskV_-1.0=0.4591102, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60994351, val_rnn_1step_R2_maskV_-1.0=0.29337659, val_rnn_1step_CC_maskV_-1.0=0.60976243, learning_rate=0.001\n", + "Epoch 73/119 - loss=rnn_1step_loss=0.43447408, rnn_1step_R2_maskV_-1.0=0.55278909, rnn_1step_CC_maskV_-1.0=0.75173521, rnn_1step_MSE_maskV_-1.0=0.43447405, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59166509, val_rnn_1step_R2_maskV_-1.0=0.31357056, val_rnn_1step_CC_maskV_-1.0=0.62336904, learning_rate=0.001\n", + "Epoch 85/119 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40931797, rnn_1step_R2_maskV_-1.0=0.57790154, rnn_1step_CC_maskV_-1.0=0.76841652, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58073461, val_rnn_1step_R2_maskV_-1.0=0.32520518, val_rnn_1step_CC_maskV_-1.0=0.63264006, learning_rate=0.001\n", + "Epoch 97/119 - loss=rnn_1step_loss=0.38480708, rnn_1step_R2_maskV_-1.0=0.60216165, rnn_1step_CC_maskV_-1.0=0.78441381, rnn_1step_MSE_maskV_-1.0=0.38480705, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58693367, val_rnn_1step_R2_maskV_-1.0=0.3172788, val_rnn_1step_CC_maskV_-1.0=0.63920861, learning_rate=0.001\n", + "Epoch 109/119 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.36848676, rnn_1step_R2_maskV_-1.0=0.6189723, rnn_1step_CC_maskV_-1.0=0.79484093, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56956083, val_rnn_1step_R2_maskV_-1.0=0.33844596, val_rnn_1step_CC_maskV_-1.0=0.65167511, learning_rate=0.001\n", + "Epoch 119/119 - loss=rnn_1step_loss=0.35392746, rnn_1step_R2_maskV_-1.0=0.63402671, rnn_1step_CC_maskV_-1.0=0.80391526, rnn_1step_MSE_maskV_-1.0=0.35392743, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56743377, val_rnn_1step_R2_maskV_-1.0=0.34102851, val_rnn_1step_CC_maskV_-1.0=0.65496325, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:18:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.84s\n", + "\u001b[32m2025-05-30 12:18:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:18:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 132 (stopped at 147 epochs).\n", + "\u001b[32m2025-05-30 12:18:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/148 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0020927, rnn_1_1step_R2_maskV_-1.0=-0.013400603, rnn_1_1step_CC_maskV_-1.0=0.052251168, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91745573, val_rnn_1_1step_R2_maskV_-1.0=-0.059636608, val_rnn_1_1step_CC_maskV_-1.0=0.24570271, learning_rate=0.001\n", + "Epoch 16/148 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.718059, rnn_1_1step_R2_maskV_-1.0=0.26841968, rnn_1_1step_CC_maskV_-1.0=0.53130829, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.72427207, val_rnn_1_1step_R2_maskV_-1.0=0.15790936, val_rnn_1_1step_CC_maskV_-1.0=0.48088861, learning_rate=0.001\n", + "Epoch 31/148 - loss=rnn_1_1step_loss=0.56173676, rnn_1_1step_R2_maskV_-1.0=0.42427433, rnn_1_1step_CC_maskV_-1.0=0.66202027, rnn_1_1step_MSE_maskV_-1.0=0.5617367, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63303638, val_rnn_1_1step_R2_maskV_-1.0=0.26697817, val_rnn_1_1step_CC_maskV_-1.0=0.57186264, learning_rate=0.001\n", + "Epoch 46/148 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.48516941, rnn_1_1step_R2_maskV_-1.0=0.50123602, rnn_1_1step_CC_maskV_-1.0=0.71724039, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60453206, val_rnn_1_1step_R2_maskV_-1.0=0.29968494, val_rnn_1_1step_CC_maskV_-1.0=0.60735393, learning_rate=0.001\n", + "Epoch 61/148 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44754884, rnn_1_1step_R2_maskV_-1.0=0.53891075, rnn_1_1step_CC_maskV_-1.0=0.74300474, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59446138, val_rnn_1_1step_R2_maskV_-1.0=0.31072459, val_rnn_1_1step_CC_maskV_-1.0=0.62050343, learning_rate=0.001\n", + "Epoch 76/148 - loss=rnn_1_1step_loss=0.41954961, rnn_1_1step_R2_maskV_-1.0=0.56714988, rnn_1_1step_CC_maskV_-1.0=0.76161885, rnn_1_1step_MSE_maskV_-1.0=0.41954967, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59238005, val_rnn_1_1step_R2_maskV_-1.0=0.31303936, val_rnn_1_1step_CC_maskV_-1.0=0.62489659, learning_rate=0.001\n", + "Epoch 91/148 - loss=rnn_1_1step_loss=0.39072767, rnn_1_1step_R2_maskV_-1.0=0.59601867, rnn_1_1step_CC_maskV_-1.0=0.78030592, rnn_1_1step_MSE_maskV_-1.0=0.3907277, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58618504, val_rnn_1_1step_R2_maskV_-1.0=0.31931287, val_rnn_1_1step_CC_maskV_-1.0=0.63987201, learning_rate=0.001\n", + "Epoch 106/148 - loss=rnn_1_1step_loss=0.3675845, rnn_1_1step_R2_maskV_-1.0=0.62002856, rnn_1_1step_CC_maskV_-1.0=0.7952705, rnn_1_1step_MSE_maskV_-1.0=0.36758453, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55492646, val_rnn_1_1step_R2_maskV_-1.0=0.35492977, val_rnn_1_1step_CC_maskV_-1.0=0.66284078, learning_rate=0.001\n", + "Epoch 121/148 - loss=rnn_1_1step_loss=0.34755647, rnn_1_1step_R2_maskV_-1.0=0.64068294, rnn_1_1step_CC_maskV_-1.0=0.80799848, rnn_1_1step_MSE_maskV_-1.0=0.34755644, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54620445, val_rnn_1_1step_R2_maskV_-1.0=0.36544201, val_rnn_1_1step_CC_maskV_-1.0=0.6711036, learning_rate=0.001\n", + "Epoch 136/148 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33953556, rnn_1_1step_R2_maskV_-1.0=0.64940161, rnn_1_1step_CC_maskV_-1.0=0.81361759, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53787929, val_rnn_1_1step_R2_maskV_-1.0=0.37576792, val_rnn_1_1step_CC_maskV_-1.0=0.68009281, learning_rate=0.001\n", + "Epoch 148/148 - loss=rnn_1_1step_loss=0.3325336, rnn_1_1step_R2_maskV_-1.0=0.6563623, rnn_1_1step_CC_maskV_-1.0=0.81807512, rnn_1_1step_MSE_maskV_-1.0=0.33253363, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49611726, val_rnn_1_1step_R2_maskV_-1.0=0.42437622, val_rnn_1_1step_CC_maskV_-1.0=0.69885242, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:18:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 17.79s\n", + "\u001b[32m2025-05-30 12:18:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.48221549)\n", + "\u001b[32m2025-05-30 12:18:47\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.336, R2_maskV_-1.0=0.664, CC_maskV_-1.0=0.817\n", + "\u001b[32m2025-05-30 12:18:47\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.465, R2_maskV_-1.0=0.473, CC_maskV_-1.0=0.717\n", + "\u001b[32m2025-05-30 12:18:47\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:18:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:19:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 141 (stopped at 156 epochs).\n", + "\u001b[32m2025-05-30 12:19:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/157 - loss=1.1882988, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.1731378, MSE_maskV_-1.0=1.1878929, val_loss=0.94312638, val_CC_maskV_-1.0=0.29888222, val_MSE_maskV_-1.0=0.94016767, learning_rate=0.001\n", + "Epoch 17/157 - loss=0.67365289, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57032615, MSE_maskV_-1.0=0.67342973, val_loss=0.71453261, val_CC_maskV_-1.0=0.54543799, val_MSE_maskV_-1.0=0.71478128, learning_rate=0.001\n", + "Epoch 33/157 - loss=0.64213091, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59624791, MSE_maskV_-1.0=0.64208901, val_loss=0.69384766, val_CC_maskV_-1.0=0.56355935, val_MSE_maskV_-1.0=0.69433188, learning_rate=0.001\n", + "Epoch 49/157 - loss=0.62813359, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60796231, MSE_maskV_-1.0=0.62819123, val_loss=0.67853618, val_CC_maskV_-1.0=0.57693428, val_MSE_maskV_-1.0=0.67815375, learning_rate=0.001\n", + "Epoch 65/157 - loss=0.61852223, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61527991, MSE_maskV_-1.0=0.61811739, val_loss=0.6693548, val_CC_maskV_-1.0=0.58378714, val_MSE_maskV_-1.0=0.66902494, learning_rate=0.001\n", + "Epoch 81/157 - loss=0.61151248, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62108868, MSE_maskV_-1.0=0.61160761, val_loss=0.66185951, val_CC_maskV_-1.0=0.59017426, val_MSE_maskV_-1.0=0.66093677, learning_rate=0.001\n", + "Epoch 97/157 - loss=0.60549569, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62591672, MSE_maskV_-1.0=0.60614371, val_loss=0.66325772, val_CC_maskV_-1.0=0.58836251, val_MSE_maskV_-1.0=0.66283709, learning_rate=0.001\n", + "Epoch 113/157 - loss=0.60128373, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62895554, MSE_maskV_-1.0=0.60338479, val_loss=0.65820205, val_CC_maskV_-1.0=0.5930388, val_MSE_maskV_-1.0=0.65750474, learning_rate=0.001\n", + "Epoch 129/157 - loss=0.59772396, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63141936, MSE_maskV_-1.0=0.59777725, val_loss=0.65769017, val_CC_maskV_-1.0=0.59343159, val_MSE_maskV_-1.0=0.65692574, learning_rate=0.001\n", + "Epoch 145/157 - loss=0.59513688, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63301325, MSE_maskV_-1.0=0.59479713, val_loss=0.65653861, val_CC_maskV_-1.0=0.59429485, val_MSE_maskV_-1.0=0.65584409, learning_rate=0.001\n", + "Epoch 157/157 - loss=0.5933708, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63522023, MSE_maskV_-1.0=0.59340525, val_loss=0.65530765, val_CC_maskV_-1.0=0.59603184, val_MSE_maskV_-1.0=0.65464056, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:19:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 41.45s\n", + "\u001b[32m2025-05-30 12:19:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:20:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 121 (stopped at 136 epochs).\n", + "\u001b[32m2025-05-30 12:20:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/137 - loss=1.1091037, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.2091908, MSE_maskV_-1.0=1.1088083, val_loss=0.91647077, val_CC_maskV_-1.0=0.33438987, val_MSE_maskV_-1.0=0.91492665, learning_rate=0.001\n", + "Epoch 15/137 - loss=0.6843189, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56035912, MSE_maskV_-1.0=0.68374771, val_loss=0.71979296, val_CC_maskV_-1.0=0.5412727, val_MSE_maskV_-1.0=0.71887952, learning_rate=0.001\n", + "Epoch 29/137 - loss=0.64851779, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59101361, MSE_maskV_-1.0=0.64808106, val_loss=0.69242865, val_CC_maskV_-1.0=0.56654996, val_MSE_maskV_-1.0=0.69101012, learning_rate=0.001\n", + "Epoch 43/137 - loss=0.63255364, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60384762, MSE_maskV_-1.0=0.63237005, val_loss=0.68096024, val_CC_maskV_-1.0=0.57522142, val_MSE_maskV_-1.0=0.67955953, learning_rate=0.001\n", + "Epoch 57/137 - loss=0.62295908, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61154836, MSE_maskV_-1.0=0.62310815, val_loss=0.67174798, val_CC_maskV_-1.0=0.58191127, val_MSE_maskV_-1.0=0.67081898, learning_rate=0.001\n", + "Epoch 71/137 - loss=0.6162495, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61737055, MSE_maskV_-1.0=0.61634517, val_loss=0.66546297, val_CC_maskV_-1.0=0.58671683, val_MSE_maskV_-1.0=0.66472709, learning_rate=0.001\n", + "Epoch 85/137 - loss=0.61058021, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62201893, MSE_maskV_-1.0=0.61058664, val_loss=0.66711479, val_CC_maskV_-1.0=0.58594579, val_MSE_maskV_-1.0=0.66651136, learning_rate=0.001\n", + "Epoch 99/137 - loss=0.60637605, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62397712, MSE_maskV_-1.0=0.60596132, val_loss=0.66083801, val_CC_maskV_-1.0=0.59068495, val_MSE_maskV_-1.0=0.66039973, learning_rate=0.001\n", + "Epoch 113/137 - loss=0.60293961, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6278519, MSE_maskV_-1.0=0.60481036, val_loss=0.65912014, val_CC_maskV_-1.0=0.59188187, val_MSE_maskV_-1.0=0.65884608, learning_rate=0.001\n", + "Epoch 127/137 - loss=0.6010372, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62979048, MSE_maskV_-1.0=0.60136896, val_loss=0.65954435, val_CC_maskV_-1.0=0.59219778, val_MSE_maskV_-1.0=0.65877962, learning_rate=0.001\n", + "Epoch 137/137 - loss=0.5989517, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63064152, MSE_maskV_-1.0=0.59914857, val_loss=0.65709096, val_CC_maskV_-1.0=0.59406698, val_MSE_maskV_-1.0=0.65650445, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:20:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 38.07s\n", + "\u001b[32m2025-05-30 12:20:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.65226549)\n", + "\u001b[32m2025-05-30 12:20:07\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 810us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:20:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.592, R2_maskV_-1.0=0.41, CC_maskV_-1.0=0.639\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 793us/step\n", + "51/51 [==============================] - 0s 829us/step\n", + "84/84 [==============================] - 0s 757us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:20:08\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_ACzCy1HL64U_ErSV16\" (14/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_ACzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:20:08\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_KCzCy1HL64U_ErSV16\" (15/16)\n", + "\u001b[32m2025-05-30 12:20:08\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:20:08\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:20:08\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:20:08\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:20:08\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:20:08\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:20:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:20:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 113 (stopped at 128 epochs).\n", + "\u001b[32m2025-05-30 12:20:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/129 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0023092, rnn_1step_R2_maskV_-1.0=-0.013637334, rnn_1step_CC_maskV_-1.0=0.041477166, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91774243, val_rnn_1step_R2_maskV_-1.0=-0.059927642, val_rnn_1step_CC_maskV_-1.0=0.30825186, learning_rate=0.001\n", + "Epoch 14/129 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.82079816, rnn_1step_R2_maskV_-1.0=0.16664328, rnn_1step_CC_maskV_-1.0=0.4296051, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.74975997, val_rnn_1step_R2_maskV_-1.0=0.13118884, val_rnn_1step_CC_maskV_-1.0=0.42860898, learning_rate=0.001\n", + "Epoch 27/129 - loss=rnn_1step_loss=0.55151278, rnn_1step_R2_maskV_-1.0=0.43625182, rnn_1step_CC_maskV_-1.0=0.66979992, rnn_1step_MSE_maskV_-1.0=0.55151272, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61360031, val_rnn_1step_R2_maskV_-1.0=0.28532904, val_rnn_1step_CC_maskV_-1.0=0.59487396, learning_rate=0.001\n", + "Epoch 40/129 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.43757963, rnn_1step_R2_maskV_-1.0=0.55135524, rnn_1step_CC_maskV_-1.0=0.74997085, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58702976, val_rnn_1step_R2_maskV_-1.0=0.31673256, val_rnn_1step_CC_maskV_-1.0=0.62557542, learning_rate=0.001\n", + "Epoch 53/129 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3735449, rnn_1step_R2_maskV_-1.0=0.61649686, rnn_1step_CC_maskV_-1.0=0.79163271, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55629754, val_rnn_1step_R2_maskV_-1.0=0.35305792, val_rnn_1step_CC_maskV_-1.0=0.65323198, learning_rate=0.001\n", + "Epoch 66/129 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32838917, rnn_1step_R2_maskV_-1.0=0.66261947, rnn_1step_CC_maskV_-1.0=0.81977081, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53061253, val_rnn_1step_R2_maskV_-1.0=0.38320637, val_rnn_1step_CC_maskV_-1.0=0.67577261, learning_rate=0.001\n", + "Epoch 79/129 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.28210092, rnn_1step_R2_maskV_-1.0=0.71038079, rnn_1step_CC_maskV_-1.0=0.84756356, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50104457, val_rnn_1step_R2_maskV_-1.0=0.41784859, val_rnn_1step_CC_maskV_-1.0=0.70031857, learning_rate=0.001\n", + "Epoch 92/129 - loss=rnn_1step_loss=0.24536283, rnn_1step_R2_maskV_-1.0=0.74810529, rnn_1step_CC_maskV_-1.0=0.86876321, rnn_1step_MSE_maskV_-1.0=0.24536285, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49851623, val_rnn_1step_R2_maskV_-1.0=0.42020282, val_rnn_1step_CC_maskV_-1.0=0.71058065, learning_rate=0.001\n", + "Epoch 105/129 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.21343148, rnn_1step_R2_maskV_-1.0=0.78047717, rnn_1step_CC_maskV_-1.0=0.88715929, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48311844, val_rnn_1step_R2_maskV_-1.0=0.43833891, val_rnn_1step_CC_maskV_-1.0=0.72061205, learning_rate=0.001\n", + "Epoch 118/129 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.20209849, rnn_1step_R2_maskV_-1.0=0.79172188, rnn_1step_CC_maskV_-1.0=0.89390796, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49493614, val_rnn_1step_R2_maskV_-1.0=0.42471495, val_rnn_1step_CC_maskV_-1.0=0.71745151, learning_rate=0.001\n", + "Epoch 129/129 - loss=rnn_1step_loss=0.18845542, rnn_1step_R2_maskV_-1.0=0.80574369, rnn_1step_CC_maskV_-1.0=0.90114582, rnn_1step_MSE_maskV_-1.0=0.18845543, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48747155, val_rnn_1step_R2_maskV_-1.0=0.43323812, val_rnn_1step_CC_maskV_-1.0=0.72326559, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:20:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.42s\n", + "\u001b[32m2025-05-30 12:20:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:20:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 99 (stopped at 114 epochs).\n", + "\u001b[32m2025-05-30 12:20:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/115 - loss=rnn_1_1step_loss=1.0023562, rnn_1_1step_R2_maskV_-1.0=-0.013681713, rnn_1_1step_CC_maskV_-1.0=0.017844755, rnn_1_1step_MSE_maskV_-1.0=1.0023563, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91829801, val_rnn_1_1step_R2_maskV_-1.0=-0.06058982, val_rnn_1_1step_CC_maskV_-1.0=0.26723111, learning_rate=0.001\n", + "Epoch 13/115 - loss=rnn_1_1step_loss=0.76505119, rnn_1_1step_R2_maskV_-1.0=0.22274014, rnn_1_1step_CC_maskV_-1.0=0.49313211, rnn_1_1step_MSE_maskV_-1.0=0.76505113, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.72087932, val_rnn_1_1step_R2_maskV_-1.0=0.16357583, val_rnn_1_1step_CC_maskV_-1.0=0.46657786, learning_rate=0.001\n", + "Epoch 25/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.60874134, rnn_1_1step_R2_maskV_-1.0=0.37660456, rnn_1_1step_CC_maskV_-1.0=0.62667018, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6729064, val_rnn_1_1step_R2_maskV_-1.0=0.21904647, val_rnn_1_1step_CC_maskV_-1.0=0.53413022, learning_rate=0.001\n", + "Epoch 37/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.52394772, rnn_1_1step_R2_maskV_-1.0=0.46282724, rnn_1_1step_CC_maskV_-1.0=0.69039804, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64542007, val_rnn_1_1step_R2_maskV_-1.0=0.25270891, val_rnn_1_1step_CC_maskV_-1.0=0.57442284, learning_rate=0.001\n", + "Epoch 49/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.45032749, rnn_1_1step_R2_maskV_-1.0=0.53806543, rnn_1_1step_CC_maskV_-1.0=0.74182749, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60827309, val_rnn_1_1step_R2_maskV_-1.0=0.29475433, val_rnn_1_1step_CC_maskV_-1.0=0.61409128, learning_rate=0.001\n", + "Epoch 61/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38340995, rnn_1_1step_R2_maskV_-1.0=0.60639322, rnn_1_1step_CC_maskV_-1.0=0.78580678, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58015901, val_rnn_1_1step_R2_maskV_-1.0=0.32636917, val_rnn_1_1step_CC_maskV_-1.0=0.64748812, learning_rate=0.001\n", + "Epoch 73/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33531952, rnn_1_1step_R2_maskV_-1.0=0.65527558, rnn_1_1step_CC_maskV_-1.0=0.81575596, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57104272, val_rnn_1_1step_R2_maskV_-1.0=0.33635306, val_rnn_1_1step_CC_maskV_-1.0=0.66271275, learning_rate=0.001\n", + "Epoch 85/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.2996248, rnn_1_1step_R2_maskV_-1.0=0.69159818, rnn_1_1step_CC_maskV_-1.0=0.83720011, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57014567, val_rnn_1_1step_R2_maskV_-1.0=0.33656245, val_rnn_1_1step_CC_maskV_-1.0=0.66940063, learning_rate=0.001\n", + "Epoch 97/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.27498379, rnn_1_1step_R2_maskV_-1.0=0.7162509, rnn_1_1step_CC_maskV_-1.0=0.85204595, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61274022, val_rnn_1_1step_R2_maskV_-1.0=0.2844879, val_rnn_1_1step_CC_maskV_-1.0=0.65908349, learning_rate=0.001\n", + "Epoch 109/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.2486323, rnn_1_1step_R2_maskV_-1.0=0.74363637, rnn_1_1step_CC_maskV_-1.0=0.86701983, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56212538, val_rnn_1_1step_R2_maskV_-1.0=0.34500843, val_rnn_1_1step_CC_maskV_-1.0=0.67862701, learning_rate=0.001\n", + "Epoch 115/115 - loss=rnn_1_1step_loss=0.2403347, rnn_1_1step_R2_maskV_-1.0=0.75216454, rnn_1_1step_CC_maskV_-1.0=0.87171936, rnn_1_1step_MSE_maskV_-1.0=0.24033469, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53856188, val_rnn_1_1step_R2_maskV_-1.0=0.37301272, val_rnn_1_1step_CC_maskV_-1.0=0.68797582, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:20:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 13.94s\n", + "\u001b[32m2025-05-30 12:20:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.47414374)\n", + "\u001b[32m2025-05-30 12:20:39\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.181, R2_maskV_-1.0=0.82, CC_maskV_-1.0=0.905\n", + "\u001b[32m2025-05-30 12:20:39\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.428, R2_maskV_-1.0=0.513, CC_maskV_-1.0=0.755\n", + "\u001b[32m2025-05-30 12:20:39\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:20:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:21:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 144 (stopped at 159 epochs).\n", + "\u001b[32m2025-05-30 12:21:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/160 - loss=1.3411705, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.099758945, MSE_maskV_-1.0=1.3404013, val_loss=1.008942, val_CC_maskV_-1.0=0.17797935, val_MSE_maskV_-1.0=1.0065591, learning_rate=0.001\n", + "Epoch 17/160 - loss=0.81829435, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42715341, MSE_maskV_-1.0=0.81822479, val_loss=0.85726267, val_CC_maskV_-1.0=0.41114923, val_MSE_maskV_-1.0=0.85355318, learning_rate=0.001\n", + "Epoch 33/160 - loss=0.78521043, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46458891, MSE_maskV_-1.0=0.78514147, val_loss=0.82744974, val_CC_maskV_-1.0=0.445402, val_MSE_maskV_-1.0=0.8238079, learning_rate=0.001\n", + "Epoch 49/160 - loss=0.76782793, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48282611, MSE_maskV_-1.0=0.76795757, val_loss=0.81767625, val_CC_maskV_-1.0=0.45693269, val_MSE_maskV_-1.0=0.81340665, learning_rate=0.001\n", + "Epoch 65/160 - loss=0.75829577, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49220237, MSE_maskV_-1.0=0.75776279, val_loss=0.80683184, val_CC_maskV_-1.0=0.46716848, val_MSE_maskV_-1.0=0.80311263, learning_rate=0.001\n", + "Epoch 81/160 - loss=0.75013351, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50078875, MSE_maskV_-1.0=0.75059879, val_loss=0.80031389, val_CC_maskV_-1.0=0.47544351, val_MSE_maskV_-1.0=0.79581654, learning_rate=0.001\n", + "Epoch 97/160 - loss=0.74431962, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50624818, MSE_maskV_-1.0=0.74481839, val_loss=0.79975444, val_CC_maskV_-1.0=0.47540197, val_MSE_maskV_-1.0=0.79563385, learning_rate=0.001\n", + "Epoch 113/160 - loss=0.7401219, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5099622, MSE_maskV_-1.0=0.74376786, val_loss=0.79984838, val_CC_maskV_-1.0=0.47582433, val_MSE_maskV_-1.0=0.79580182, learning_rate=0.001\n", + "Epoch 129/160 - loss=0.73687667, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51325357, MSE_maskV_-1.0=0.73693269, val_loss=0.7924279, val_CC_maskV_-1.0=0.48329443, val_MSE_maskV_-1.0=0.78826058, learning_rate=0.001\n", + "Epoch 145/160 - loss=0.73372519, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51592207, MSE_maskV_-1.0=0.73339951, val_loss=0.794249, val_CC_maskV_-1.0=0.48285469, val_MSE_maskV_-1.0=0.7902503, learning_rate=0.001\n", + "Epoch 160/160 - loss=0.73023301, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52008039, MSE_maskV_-1.0=0.73012424, val_loss=0.79312408, val_CC_maskV_-1.0=0.48345536, val_MSE_maskV_-1.0=0.78921682, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:21:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 42.44s\n", + "\u001b[32m2025-05-30 12:21:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:22:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 175 (stopped at 190 epochs).\n", + "\u001b[32m2025-05-30 12:22:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/191 - loss=1.393654, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.083314583, MSE_maskV_-1.0=1.3926537, val_loss=1.0229123, val_CC_maskV_-1.0=0.1539872, val_MSE_maskV_-1.0=1.0195713, learning_rate=0.001\n", + "Epoch 21/191 - loss=0.81616098, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42965612, MSE_maskV_-1.0=0.81630033, val_loss=0.84832317, val_CC_maskV_-1.0=0.42086783, val_MSE_maskV_-1.0=0.8445664, learning_rate=0.001\n", + "Epoch 41/191 - loss=0.77989656, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46926293, MSE_maskV_-1.0=0.78432542, val_loss=0.82625884, val_CC_maskV_-1.0=0.44757247, val_MSE_maskV_-1.0=0.82263321, learning_rate=0.001\n", + "Epoch 61/191 - loss=0.76269829, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48799545, MSE_maskV_-1.0=0.76361746, val_loss=0.81071341, val_CC_maskV_-1.0=0.46334457, val_MSE_maskV_-1.0=0.80716813, learning_rate=0.001\n", + "Epoch 81/191 - loss=0.75178474, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49920005, MSE_maskV_-1.0=0.75232941, val_loss=0.80114943, val_CC_maskV_-1.0=0.47313514, val_MSE_maskV_-1.0=0.79777861, learning_rate=0.001\n", + "Epoch 101/191 - loss=0.74485856, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50637496, MSE_maskV_-1.0=0.74402863, val_loss=0.79886484, val_CC_maskV_-1.0=0.4764277, val_MSE_maskV_-1.0=0.79571348, learning_rate=0.001\n", + "Epoch 121/191 - loss=0.73871899, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51195949, MSE_maskV_-1.0=0.73887748, val_loss=0.80184424, val_CC_maskV_-1.0=0.47446439, val_MSE_maskV_-1.0=0.79897839, learning_rate=0.001\n", + "Epoch 141/191 - loss=0.73519307, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51595771, MSE_maskV_-1.0=0.73431444, val_loss=0.78988427, val_CC_maskV_-1.0=0.48575574, val_MSE_maskV_-1.0=0.7864536, learning_rate=0.001\n", + "Epoch 161/191 - loss=0.73032182, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51975727, MSE_maskV_-1.0=0.73020375, val_loss=0.79319835, val_CC_maskV_-1.0=0.48309693, val_MSE_maskV_-1.0=0.79001004, learning_rate=0.001\n", + "Epoch 181/191 - loss=0.72942758, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52093488, MSE_maskV_-1.0=0.72990507, val_loss=0.79111159, val_CC_maskV_-1.0=0.48570555, val_MSE_maskV_-1.0=0.78766167, learning_rate=0.001\n", + "Epoch 191/191 - loss=0.72778773, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52164173, MSE_maskV_-1.0=0.72792822, val_loss=0.78737456, val_CC_maskV_-1.0=0.48825353, val_MSE_maskV_-1.0=0.78439796, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:22:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 50.00s\n", + "\u001b[32m2025-05-30 12:22:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.78377199)\n", + "\u001b[32m2025-05-30 12:22:12\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 813us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:22:12\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.724, R2_maskV_-1.0=0.276, CC_maskV_-1.0=0.526\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 804us/step\n", + "51/51 [==============================] - 0s 804us/step\n", + "84/84 [==============================] - 0s 749us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:22:13\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_KCzCy1HL64U_ErSV16\" (15/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_KCzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:22:13\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16\" (16/16)\n", + "\u001b[32m2025-05-30 12:22:13\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:22:13\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:22:13\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:22:13\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:22:13\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:22:13\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:22:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:22:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 143 (stopped at 158 epochs).\n", + "\u001b[32m2025-05-30 12:22:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/159 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0022528, rnn_1step_R2_maskV_-1.0=-0.013580214, rnn_1step_CC_maskV_-1.0=0.052695625, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91773397, val_rnn_1step_R2_maskV_-1.0=-0.059917167, val_rnn_1step_CC_maskV_-1.0=0.3034324, learning_rate=0.001\n", + "Epoch 17/159 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.66413873, rnn_1step_R2_maskV_-1.0=0.32102808, rnn_1step_CC_maskV_-1.0=0.58131468, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.67293978, val_rnn_1step_R2_maskV_-1.0=0.21817905, val_rnn_1step_CC_maskV_-1.0=0.52254975, learning_rate=0.001\n", + "Epoch 33/159 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.53099316, rnn_1step_R2_maskV_-1.0=0.45402026, rnn_1step_CC_maskV_-1.0=0.68514538, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63926369, val_rnn_1step_R2_maskV_-1.0=0.25710881, val_rnn_1step_CC_maskV_-1.0=0.56770331, learning_rate=0.001\n", + "Epoch 49/159 - loss=rnn_1step_loss=0.4460043, rnn_1step_R2_maskV_-1.0=0.53963012, rnn_1step_CC_maskV_-1.0=0.74430537, rnn_1step_MSE_maskV_-1.0=0.44600433, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61054671, val_rnn_1step_R2_maskV_-1.0=0.29026791, val_rnn_1step_CC_maskV_-1.0=0.60253221, learning_rate=0.001\n", + "Epoch 65/159 - loss=rnn_1step_loss=0.40816012, rnn_1step_R2_maskV_-1.0=0.57770371, rnn_1step_CC_maskV_-1.0=0.76978356, rnn_1step_MSE_maskV_-1.0=0.40816015, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61157084, val_rnn_1step_R2_maskV_-1.0=0.28890231, val_rnn_1step_CC_maskV_-1.0=0.61080408, learning_rate=0.001\n", + "Epoch 81/159 - loss=rnn_1step_loss=0.37197408, rnn_1step_R2_maskV_-1.0=0.61432403, rnn_1step_CC_maskV_-1.0=0.79378641, rnn_1step_MSE_maskV_-1.0=0.37197411, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58682919, val_rnn_1step_R2_maskV_-1.0=0.31816119, val_rnn_1step_CC_maskV_-1.0=0.62546986, learning_rate=0.001\n", + "Epoch 97/159 - loss=rnn_1step_loss=0.34474412, rnn_1step_R2_maskV_-1.0=0.64226985, rnn_1step_CC_maskV_-1.0=0.81037992, rnn_1step_MSE_maskV_-1.0=0.34474415, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58134538, val_rnn_1step_R2_maskV_-1.0=0.32461059, val_rnn_1step_CC_maskV_-1.0=0.6313647, learning_rate=0.001\n", + "Epoch 113/159 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31800237, rnn_1step_R2_maskV_-1.0=0.66954786, rnn_1step_CC_maskV_-1.0=0.82652974, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57080168, val_rnn_1step_R2_maskV_-1.0=0.33704519, val_rnn_1step_CC_maskV_-1.0=0.64189446, learning_rate=0.001\n", + "Epoch 129/159 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29966518, rnn_1step_R2_maskV_-1.0=0.68813312, rnn_1step_CC_maskV_-1.0=0.83748847, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58519673, val_rnn_1step_R2_maskV_-1.0=0.31972307, val_rnn_1step_CC_maskV_-1.0=0.63663501, learning_rate=0.001\n", + "Epoch 145/159 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27841017, rnn_1step_R2_maskV_-1.0=0.70989406, rnn_1step_CC_maskV_-1.0=0.84974837, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59350187, val_rnn_1step_R2_maskV_-1.0=0.30986255, val_rnn_1step_CC_maskV_-1.0=0.63458949, learning_rate=0.001\n", + "Epoch 159/159 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.26494789, rnn_1step_R2_maskV_-1.0=0.7240299, rnn_1step_CC_maskV_-1.0=0.85802954, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56975126, val_rnn_1step_R2_maskV_-1.0=0.33963883, val_rnn_1step_CC_maskV_-1.0=0.64644492, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:22:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 19.58s\n", + "\u001b[32m2025-05-30 12:22:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:22:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 90 (stopped at 105 epochs).\n", + "\u001b[32m2025-05-30 12:22:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/106 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0022818, rnn_1_1step_R2_maskV_-1.0=-0.013612635, rnn_1_1step_CC_maskV_-1.0=0.074726336, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91799992, val_rnn_1_1step_R2_maskV_-1.0=-0.060212418, val_rnn_1_1step_CC_maskV_-1.0=0.30000064, learning_rate=0.001\n", + "Epoch 12/106 - loss=rnn_1_1step_loss=0.78735542, rnn_1_1step_R2_maskV_-1.0=0.19626346, rnn_1_1step_CC_maskV_-1.0=0.46333399, rnn_1_1step_MSE_maskV_-1.0=0.78735536, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.76184636, val_rnn_1_1step_R2_maskV_-1.0=0.11899744, val_rnn_1_1step_CC_maskV_-1.0=0.43291223, learning_rate=0.001\n", + "Epoch 23/106 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.6307717, rnn_1_1step_R2_maskV_-1.0=0.3541286, rnn_1_1step_CC_maskV_-1.0=0.60796988, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65886688, val_rnn_1_1step_R2_maskV_-1.0=0.23652346, val_rnn_1_1step_CC_maskV_-1.0=0.5402835, learning_rate=0.001\n", + "Epoch 34/106 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.53353363, rnn_1_1step_R2_maskV_-1.0=0.45161775, rnn_1_1step_CC_maskV_-1.0=0.68319982, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60873586, val_rnn_1_1step_R2_maskV_-1.0=0.29376867, val_rnn_1_1step_CC_maskV_-1.0=0.59321141, learning_rate=0.001\n", + "Epoch 45/106 - loss=rnn_1_1step_loss=0.46448174, rnn_1_1step_R2_maskV_-1.0=0.52151525, rnn_1_1step_CC_maskV_-1.0=0.73180521, rnn_1_1step_MSE_maskV_-1.0=0.46448171, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57738233, val_rnn_1_1step_R2_maskV_-1.0=0.32973665, val_rnn_1_1step_CC_maskV_-1.0=0.62265247, learning_rate=0.001\n", + "Epoch 56/106 - loss=rnn_1_1step_loss=0.41058478, rnn_1_1step_R2_maskV_-1.0=0.57655567, rnn_1_1step_CC_maskV_-1.0=0.76855725, rnn_1_1step_MSE_maskV_-1.0=0.41058475, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56669992, val_rnn_1_1step_R2_maskV_-1.0=0.34298009, val_rnn_1_1step_CC_maskV_-1.0=0.63876963, learning_rate=0.001\n", + "Epoch 67/106 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38271418, rnn_1_1step_R2_maskV_-1.0=0.60388839, rnn_1_1step_CC_maskV_-1.0=0.78921038, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55777293, val_rnn_1_1step_R2_maskV_-1.0=0.35235459, val_rnn_1_1step_CC_maskV_-1.0=0.65584326, learning_rate=0.001\n", + "Epoch 78/106 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.3542172, rnn_1_1step_R2_maskV_-1.0=0.63403648, rnn_1_1step_CC_maskV_-1.0=0.80389124, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56767625, val_rnn_1_1step_R2_maskV_-1.0=0.34029257, val_rnn_1_1step_CC_maskV_-1.0=0.65882719, learning_rate=0.001\n", + "Epoch 89/106 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.34217677, rnn_1_1step_R2_maskV_-1.0=0.64609826, rnn_1_1step_CC_maskV_-1.0=0.81344783, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55501419, val_rnn_1_1step_R2_maskV_-1.0=0.35496682, val_rnn_1_1step_CC_maskV_-1.0=0.6651907, learning_rate=0.001\n", + "Epoch 100/106 - loss=rnn_1_1step_loss=0.32372943, rnn_1_1step_R2_maskV_-1.0=0.66558325, rnn_1_1step_CC_maskV_-1.0=0.82226801, rnn_1_1step_MSE_maskV_-1.0=0.3237294, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55647188, val_rnn_1_1step_R2_maskV_-1.0=0.3533836, val_rnn_1_1step_CC_maskV_-1.0=0.66669393, learning_rate=0.001\n", + "Epoch 106/106 - loss=rnn_1_1step_loss=0.3215113, rnn_1_1step_R2_maskV_-1.0=0.66675997, rnn_1_1step_CC_maskV_-1.0=0.82528621, rnn_1_1step_MSE_maskV_-1.0=0.32151133, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54604727, val_rnn_1_1step_R2_maskV_-1.0=0.36569506, val_rnn_1_1step_CC_maskV_-1.0=0.67174059, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:22:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.27s\n", + "\u001b[32m2025-05-30 12:22:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.53082269)\n", + "\u001b[32m2025-05-30 12:22:48\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.332, R2_maskV_-1.0=0.668, CC_maskV_-1.0=0.823\n", + "\u001b[32m2025-05-30 12:22:49\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.508, R2_maskV_-1.0=0.424, CC_maskV_-1.0=0.689\n", + "\u001b[32m2025-05-30 12:22:49\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:22:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:23:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 139 (stopped at 154 epochs).\n", + "\u001b[32m2025-05-30 12:23:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/155 - loss=1.2615443, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.13197403, MSE_maskV_-1.0=1.2609491, val_loss=0.98015934, val_CC_maskV_-1.0=0.22456507, val_MSE_maskV_-1.0=0.97730619, learning_rate=0.001\n", + "Epoch 17/155 - loss=0.81001961, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43652952, MSE_maskV_-1.0=0.81008333, val_loss=0.84996247, val_CC_maskV_-1.0=0.42197904, val_MSE_maskV_-1.0=0.84714615, learning_rate=0.001\n", + "Epoch 33/155 - loss=0.78157836, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46884122, MSE_maskV_-1.0=0.78157896, val_loss=0.8296724, val_CC_maskV_-1.0=0.44334984, val_MSE_maskV_-1.0=0.82718778, learning_rate=0.001\n", + "Epoch 49/155 - loss=0.76326758, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48762652, MSE_maskV_-1.0=0.76339883, val_loss=0.81509358, val_CC_maskV_-1.0=0.46109331, val_MSE_maskV_-1.0=0.81189966, learning_rate=0.001\n", + "Epoch 65/155 - loss=0.75087982, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49937513, MSE_maskV_-1.0=0.75034267, val_loss=0.7968843, val_CC_maskV_-1.0=0.47706953, val_MSE_maskV_-1.0=0.79406923, learning_rate=0.001\n", + "Epoch 81/155 - loss=0.74182802, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50894946, MSE_maskV_-1.0=0.74196637, val_loss=0.78406703, val_CC_maskV_-1.0=0.4895997, val_MSE_maskV_-1.0=0.78147513, learning_rate=0.001\n", + "Epoch 97/155 - loss=0.7342602, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.515248, MSE_maskV_-1.0=0.73492545, val_loss=0.77941072, val_CC_maskV_-1.0=0.49379802, val_MSE_maskV_-1.0=0.77621073, learning_rate=0.001\n", + "Epoch 113/155 - loss=0.72671962, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52230549, MSE_maskV_-1.0=0.73010057, val_loss=0.78462678, val_CC_maskV_-1.0=0.49139079, val_MSE_maskV_-1.0=0.78283417, learning_rate=0.001\n", + "Epoch 129/155 - loss=0.72134876, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5270462, MSE_maskV_-1.0=0.72151935, val_loss=0.76582825, val_CC_maskV_-1.0=0.50675547, val_MSE_maskV_-1.0=0.76225632, learning_rate=0.001\n", + "Epoch 145/155 - loss=0.71841198, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52943391, MSE_maskV_-1.0=0.71800822, val_loss=0.76062953, val_CC_maskV_-1.0=0.51014668, val_MSE_maskV_-1.0=0.7581749, learning_rate=0.001\n", + "Epoch 155/155 - loss=0.71493345, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53332281, MSE_maskV_-1.0=0.71587229, val_loss=0.7646783, val_CC_maskV_-1.0=0.50966108, val_MSE_maskV_-1.0=0.7615366, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:23:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 41.98s\n", + "\u001b[32m2025-05-30 12:23:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:24:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 117 (stopped at 132 epochs).\n", + "\u001b[32m2025-05-30 12:24:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/133 - loss=1.2363516, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.12726362, MSE_maskV_-1.0=1.235919, val_loss=0.98276567, val_CC_maskV_-1.0=0.22215973, val_MSE_maskV_-1.0=0.97933978, learning_rate=0.001\n", + "Epoch 15/133 - loss=0.81655204, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42880684, MSE_maskV_-1.0=0.81571507, val_loss=0.85981697, val_CC_maskV_-1.0=0.40927354, val_MSE_maskV_-1.0=0.8571524, learning_rate=0.001\n", + "Epoch 29/133 - loss=0.79011148, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45891011, MSE_maskV_-1.0=0.78942251, val_loss=0.8416838, val_CC_maskV_-1.0=0.43158168, val_MSE_maskV_-1.0=0.83903444, learning_rate=0.001\n", + "Epoch 43/133 - loss=0.77190304, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47826514, MSE_maskV_-1.0=0.77165794, val_loss=0.82996613, val_CC_maskV_-1.0=0.44643158, val_MSE_maskV_-1.0=0.82686287, learning_rate=0.001\n", + "Epoch 57/133 - loss=0.7583248, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49219847, MSE_maskV_-1.0=0.75907493, val_loss=0.81406689, val_CC_maskV_-1.0=0.46192941, val_MSE_maskV_-1.0=0.81065017, learning_rate=0.001\n", + "Epoch 71/133 - loss=0.74849164, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50145382, MSE_maskV_-1.0=0.74973446, val_loss=0.79547131, val_CC_maskV_-1.0=0.47943926, val_MSE_maskV_-1.0=0.79158664, learning_rate=0.001\n", + "Epoch 85/133 - loss=0.74016875, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50997669, MSE_maskV_-1.0=0.74022365, val_loss=0.79763979, val_CC_maskV_-1.0=0.47911039, val_MSE_maskV_-1.0=0.79378998, learning_rate=0.001\n", + "Epoch 99/133 - loss=0.73413163, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51547676, MSE_maskV_-1.0=0.73351973, val_loss=0.7857191, val_CC_maskV_-1.0=0.49063611, val_MSE_maskV_-1.0=0.78171456, learning_rate=0.001\n", + "Epoch 113/133 - loss=0.72758979, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52175963, MSE_maskV_-1.0=0.73090774, val_loss=0.79785949, val_CC_maskV_-1.0=0.4804469, val_MSE_maskV_-1.0=0.79539126, learning_rate=0.001\n", + "Epoch 127/133 - loss=0.72506511, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52415878, MSE_maskV_-1.0=0.72527266, val_loss=0.78178793, val_CC_maskV_-1.0=0.49514702, val_MSE_maskV_-1.0=0.77838629, learning_rate=0.001\n", + "Epoch 133/133 - loss=0.72225577, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52672172, MSE_maskV_-1.0=0.72210222, val_loss=0.77676022, val_CC_maskV_-1.0=0.49628782, val_MSE_maskV_-1.0=0.77430761, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:24:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 35.41s\n", + "\u001b[32m2025-05-30 12:24:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.75561899)\n", + "\u001b[32m2025-05-30 12:24:06\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 818us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:24:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.713, R2_maskV_-1.0=0.288, CC_maskV_-1.0=0.536\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 810us/step\n", + "51/51 [==============================] - 0s 957us/step\n", + "84/84 [==============================] - 0s 741us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:24:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16\" (16/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_uAKCzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:24:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1948] \u001b[1;30mINFO\u001b[0m Saving results for fold 3 as ..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4.p\n", + "\u001b[32m2025-05-30 12:24:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1381] \u001b[1;30mINFO\u001b[0m Fold 4/4: training samples: 8016, test samples=2670\n", + "\u001b[32m2025-05-30 12:24:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1754] \u001b[1;30mINFO\u001b[0m Running fold 4 (NTrain=8016, NTest=2670)\n", + "\u001b[32m2025-05-30 12:24:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1849] \u001b[1;30mINFO\u001b[0m Signal dimensions: y => (10686, 46), z => (10686, 4), u => None\n", + "\u001b[32m2025-05-30 12:24:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1856] \u001b[1;30mINFO\u001b[0m Method codes to fit: ['DPAD_RTR2_ErSV16', 'DPAD_RTR2_A1HL64U_ErSV16', 'DPAD_RTR2_K1HL64U_ErSV16', 'DPAD_RTR2_Cz1HL64U_ErSV16', 'DPAD_RTR2_Cy1HL64U_ErSV16', 'DPAD_RTR2_uAK1HL64U_ErSV16', 'DPAD_RTR2_ACz1HL64U_ErSV16', 'DPAD_RTR2_ACy1HL64U_ErSV16', 'DPAD_RTR2_KCz1HL64U_ErSV16', 'DPAD_RTR2_KCy1HL64U_ErSV16', 'DPAD_RTR2_CzCy1HL64U_ErSV16', 'DPAD_RTR2_uAKCz1HL64U_ErSV16', 'DPAD_RTR2_uAKCy1HL64U_ErSV16', 'DPAD_RTR2_ACzCy1HL64U_ErSV16', 'DPAD_RTR2_KCzCy1HL64U_ErSV16', 'DPAD_RTR2_uAKCzCy1HL64U_ErSV16']\n", + "\u001b[32m2025-05-30 12:24:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1857] \u001b[1;30mINFO\u001b[0m Nx values to fit: [16]\n", + "\u001b[32m2025-05-30 12:24:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_ErSV16\" (1/16)\n", + "\u001b[32m2025-05-30 12:24:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:24:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:24:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:24:08\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:24:08\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:24:08\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:24:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:24:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 221 (stopped at 236 epochs).\n", + "\u001b[32m2025-05-30 12:24:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/237 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0079309, rnn_1step_R2_maskV_-1.0=-0.013163164, rnn_1step_CC_maskV_-1.0=-0.032103091, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0890769, val_rnn_1step_R2_maskV_-1.0=-0.041977108, val_rnn_1step_CC_maskV_-1.0=0.061904863, learning_rate=0.001\n", + "Epoch 25/237 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.60327071, rnn_1step_R2_maskV_-1.0=0.38834769, rnn_1step_CC_maskV_-1.0=0.63151282, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6827178, val_rnn_1step_R2_maskV_-1.0=0.34498623, val_rnn_1step_CC_maskV_-1.0=0.60952884, learning_rate=0.001\n", + "Epoch 49/237 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.50163835, rnn_1step_R2_maskV_-1.0=0.49013966, rnn_1step_CC_maskV_-1.0=0.70736229, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53326768, val_rnn_1step_R2_maskV_-1.0=0.49004287, val_rnn_1step_CC_maskV_-1.0=0.71212351, learning_rate=0.001\n", + "Epoch 73/237 - loss=rnn_1step_loss=0.48152038, rnn_1step_R2_maskV_-1.0=0.51000983, rnn_1step_CC_maskV_-1.0=0.72144628, rnn_1step_MSE_maskV_-1.0=0.48152035, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51073641, val_rnn_1step_R2_maskV_-1.0=0.51097596, val_rnn_1step_CC_maskV_-1.0=0.72750169, learning_rate=0.001\n", + "Epoch 97/237 - loss=rnn_1step_loss=0.44767383, rnn_1step_R2_maskV_-1.0=0.54424417, rnn_1step_CC_maskV_-1.0=0.74460322, rnn_1step_MSE_maskV_-1.0=0.4476738, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49506858, val_rnn_1step_R2_maskV_-1.0=0.52532041, val_rnn_1step_CC_maskV_-1.0=0.73726046, learning_rate=0.001\n", + "Epoch 121/237 - loss=rnn_1step_loss=0.42408586, rnn_1step_R2_maskV_-1.0=0.56762409, rnn_1step_CC_maskV_-1.0=0.76022732, rnn_1step_MSE_maskV_-1.0=0.42408583, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48351407, val_rnn_1step_R2_maskV_-1.0=0.53749883, val_rnn_1step_CC_maskV_-1.0=0.744259, learning_rate=0.001\n", + "Epoch 145/237 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4203676, rnn_1step_R2_maskV_-1.0=0.57101601, rnn_1step_CC_maskV_-1.0=0.76255298, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47957489, val_rnn_1step_R2_maskV_-1.0=0.54149181, val_rnn_1step_CC_maskV_-1.0=0.74638218, learning_rate=0.001\n", + "Epoch 169/237 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41852286, rnn_1step_R2_maskV_-1.0=0.5726822, rnn_1step_CC_maskV_-1.0=0.76369351, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47820678, val_rnn_1step_R2_maskV_-1.0=0.54283041, val_rnn_1step_CC_maskV_-1.0=0.74705839, learning_rate=0.001\n", + "Epoch 193/237 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41735828, rnn_1step_R2_maskV_-1.0=0.57376659, rnn_1step_CC_maskV_-1.0=0.76441497, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47748911, val_rnn_1step_R2_maskV_-1.0=0.54351372, val_rnn_1step_CC_maskV_-1.0=0.74741119, learning_rate=0.001\n", + "Epoch 217/237 - loss=rnn_1step_loss=0.41654113, rnn_1step_R2_maskV_-1.0=0.57454288, rnn_1step_CC_maskV_-1.0=0.76492202, rnn_1step_MSE_maskV_-1.0=0.41654116, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47725317, val_rnn_1step_R2_maskV_-1.0=0.54371232, val_rnn_1step_CC_maskV_-1.0=0.7475009, learning_rate=0.001\n", + "Epoch 237/237 - loss=rnn_1step_loss=0.41604748, rnn_1step_R2_maskV_-1.0=0.57501274, rnn_1step_CC_maskV_-1.0=0.76522833, rnn_1step_MSE_maskV_-1.0=0.41604745, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47730431, val_rnn_1step_R2_maskV_-1.0=0.54363179, val_rnn_1step_CC_maskV_-1.0=0.74743527, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:24:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 23.00s\n", + "\u001b[32m2025-05-30 12:24:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:24:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 179 (stopped at 194 epochs).\n", + "\u001b[32m2025-05-30 12:24:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/195 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.001688, rnn_1_1step_R2_maskV_-1.0=-0.0066961572, rnn_1_1step_CC_maskV_-1.0=0.089926362, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0779638, val_rnn_1_1step_R2_maskV_-1.0=-0.031569704, val_rnn_1_1step_CC_maskV_-1.0=0.23632658, learning_rate=0.001\n", + "Epoch 21/195 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.61992413, rnn_1_1step_R2_maskV_-1.0=0.37238818, rnn_1_1step_CC_maskV_-1.0=0.61741066, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.68828005, val_rnn_1_1step_R2_maskV_-1.0=0.33687085, val_rnn_1_1step_CC_maskV_-1.0=0.60484433, learning_rate=0.001\n", + "Epoch 41/195 - loss=rnn_1_1step_loss=0.50591016, rnn_1_1step_R2_maskV_-1.0=0.48538753, rnn_1_1step_CC_maskV_-1.0=0.70429009, rnn_1_1step_MSE_maskV_-1.0=0.5059101, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55083984, val_rnn_1_1step_R2_maskV_-1.0=0.47301489, val_rnn_1_1step_CC_maskV_-1.0=0.69954163, learning_rate=0.001\n", + "Epoch 61/195 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.47935179, rnn_1_1step_R2_maskV_-1.0=0.51216918, rnn_1_1step_CC_maskV_-1.0=0.72295487, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51441419, val_rnn_1_1step_R2_maskV_-1.0=0.50809133, val_rnn_1_1step_CC_maskV_-1.0=0.72454578, learning_rate=0.001\n", + "Epoch 81/195 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44344285, rnn_1_1step_R2_maskV_-1.0=0.54851526, rnn_1_1step_CC_maskV_-1.0=0.74744916, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49436894, val_rnn_1_1step_R2_maskV_-1.0=0.52660501, val_rnn_1_1step_CC_maskV_-1.0=0.73730922, learning_rate=0.001\n", + "Epoch 101/195 - loss=rnn_1_1step_loss=0.42595282, rnn_1_1step_R2_maskV_-1.0=0.5656755, rnn_1_1step_CC_maskV_-1.0=0.75893724, rnn_1_1step_MSE_maskV_-1.0=0.42595285, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48269498, val_rnn_1_1step_R2_maskV_-1.0=0.53840053, val_rnn_1_1step_CC_maskV_-1.0=0.7443983, learning_rate=0.001\n", + "Epoch 121/195 - loss=rnn_1_1step_loss=0.4224852, rnn_1_1step_R2_maskV_-1.0=0.56878704, rnn_1_1step_CC_maskV_-1.0=0.76112598, rnn_1_1step_MSE_maskV_-1.0=0.42248523, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47919083, val_rnn_1_1step_R2_maskV_-1.0=0.54182678, val_rnn_1_1step_CC_maskV_-1.0=0.74646568, learning_rate=0.001\n", + "Epoch 141/195 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42050076, rnn_1_1step_R2_maskV_-1.0=0.57060778, rnn_1_1step_CC_maskV_-1.0=0.76236784, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47717133, val_rnn_1_1step_R2_maskV_-1.0=0.54379094, val_rnn_1_1step_CC_maskV_-1.0=0.74760157, learning_rate=0.001\n", + "Epoch 161/195 - loss=rnn_1_1step_loss=0.41931084, rnn_1_1step_R2_maskV_-1.0=0.57169843, rnn_1_1step_CC_maskV_-1.0=0.76310265, rnn_1_1step_MSE_maskV_-1.0=0.41931087, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47615576, val_rnn_1_1step_R2_maskV_-1.0=0.54478431, val_rnn_1_1step_CC_maskV_-1.0=0.74811298, learning_rate=0.001\n", + "Epoch 181/195 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41850242, rnn_1_1step_R2_maskV_-1.0=0.57244074, rnn_1_1step_CC_maskV_-1.0=0.7635994, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47590652, val_rnn_1_1step_R2_maskV_-1.0=0.54503238, val_rnn_1_1step_CC_maskV_-1.0=0.7481584, learning_rate=0.001\n", + "Epoch 195/195 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.4180713, rnn_1_1step_R2_maskV_-1.0=0.57283962, rnn_1_1step_CC_maskV_-1.0=0.76386511, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47603348, val_rnn_1_1step_R2_maskV_-1.0=0.54491186, val_rnn_1_1step_CC_maskV_-1.0=0.7480129, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:24:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 18.41s\n", + "\u001b[32m2025-05-30 12:24:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.47590518)\n", + "\u001b[32m2025-05-30 12:24:50\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.362, R2_maskV_-1.0=0.638, CC_maskV_-1.0=0.799\n", + "\u001b[32m2025-05-30 12:24:51\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.464, R2_maskV_-1.0=0.545, CC_maskV_-1.0=0.75\n", + "\u001b[32m2025-05-30 12:24:51\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:24:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:25:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 188 (stopped at 203 epochs).\n", + "\u001b[32m2025-05-30 12:25:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/204 - loss=11.002884, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0010730273, MSE_maskV_-1.0=10.975224, val_loss=1.7427384, val_CC_maskV_-1.0=0.017141288, val_MSE_maskV_-1.0=1.7305275, learning_rate=0.001\n", + "Epoch 22/204 - loss=0.90492183, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.31148767, MSE_maskV_-1.0=0.90472883, val_loss=0.97119826, val_CC_maskV_-1.0=0.29080805, val_MSE_maskV_-1.0=0.96687591, learning_rate=0.001\n", + "Epoch 43/204 - loss=0.85381496, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38252649, MSE_maskV_-1.0=0.85290647, val_loss=0.92826003, val_CC_maskV_-1.0=0.3531127, val_MSE_maskV_-1.0=0.92390555, learning_rate=0.001\n", + "Epoch 64/204 - loss=0.82588172, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41916382, MSE_maskV_-1.0=0.82630759, val_loss=0.89475322, val_CC_maskV_-1.0=0.39601681, val_MSE_maskV_-1.0=0.89073509, learning_rate=0.001\n", + "Epoch 85/204 - loss=0.80775493, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44062468, MSE_maskV_-1.0=0.8081972, val_loss=0.8741889, val_CC_maskV_-1.0=0.41994166, val_MSE_maskV_-1.0=0.87051278, learning_rate=0.001\n", + "Epoch 106/204 - loss=0.7937237, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45662484, MSE_maskV_-1.0=0.79355133, val_loss=0.86119777, val_CC_maskV_-1.0=0.43402824, val_MSE_maskV_-1.0=0.8575809, learning_rate=0.001\n", + "Epoch 127/204 - loss=0.78360307, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46726429, MSE_maskV_-1.0=0.78328633, val_loss=0.84999079, val_CC_maskV_-1.0=0.44472161, val_MSE_maskV_-1.0=0.84648335, learning_rate=0.001\n", + "Epoch 148/204 - loss=0.77534229, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47534928, MSE_maskV_-1.0=0.77458251, val_loss=0.84101826, val_CC_maskV_-1.0=0.45336577, val_MSE_maskV_-1.0=0.83775115, learning_rate=0.001\n", + "Epoch 169/204 - loss=0.76978302, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4816519, MSE_maskV_-1.0=0.77026367, val_loss=0.83099896, val_CC_maskV_-1.0=0.4661077, val_MSE_maskV_-1.0=0.82770735, learning_rate=0.001\n", + "Epoch 190/204 - loss=0.76370662, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48749834, MSE_maskV_-1.0=0.7631712, val_loss=0.82340443, val_CC_maskV_-1.0=0.46939644, val_MSE_maskV_-1.0=0.82012844, learning_rate=0.001\n", + "Epoch 204/204 - loss=0.76087677, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48995006, MSE_maskV_-1.0=0.7611472, val_loss=0.83118284, val_CC_maskV_-1.0=0.46409655, val_MSE_maskV_-1.0=0.82785398, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:25:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 49.72s\n", + "\u001b[32m2025-05-30 12:25:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:26:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 154 (stopped at 169 epochs).\n", + "\u001b[32m2025-05-30 12:26:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/170 - loss=12.390624, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=-0.0066562723, MSE_maskV_-1.0=12.359709, val_loss=1.9003235, val_CC_maskV_-1.0=0.00779386, val_MSE_maskV_-1.0=1.8903992, learning_rate=0.001\n", + "Epoch 18/170 - loss=0.91171771, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.30075446, MSE_maskV_-1.0=0.91173011, val_loss=0.99134547, val_CC_maskV_-1.0=0.26836795, val_MSE_maskV_-1.0=0.98769516, learning_rate=0.001\n", + "Epoch 35/170 - loss=0.85731924, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37931335, MSE_maskV_-1.0=0.85710943, val_loss=0.92892408, val_CC_maskV_-1.0=0.35015032, val_MSE_maskV_-1.0=0.92501175, learning_rate=0.001\n", + "Epoch 52/170 - loss=0.83247554, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41059884, MSE_maskV_-1.0=0.83246839, val_loss=0.90314472, val_CC_maskV_-1.0=0.38330925, val_MSE_maskV_-1.0=0.89924186, learning_rate=0.001\n", + "Epoch 69/170 - loss=0.81593531, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43128547, MSE_maskV_-1.0=0.81582302, val_loss=0.87948281, val_CC_maskV_-1.0=0.41089937, val_MSE_maskV_-1.0=0.8757394, learning_rate=0.001\n", + "Epoch 86/170 - loss=0.80261075, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44621724, MSE_maskV_-1.0=0.80308038, val_loss=0.87282699, val_CC_maskV_-1.0=0.42291343, val_MSE_maskV_-1.0=0.86916155, learning_rate=0.001\n", + "Epoch 103/170 - loss=0.79235822, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4584924, MSE_maskV_-1.0=0.79235536, val_loss=0.85650468, val_CC_maskV_-1.0=0.43849725, val_MSE_maskV_-1.0=0.85307717, learning_rate=0.001\n", + "Epoch 120/170 - loss=0.78438139, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46660542, MSE_maskV_-1.0=0.78421384, val_loss=0.85400194, val_CC_maskV_-1.0=0.44410056, val_MSE_maskV_-1.0=0.85026401, learning_rate=0.001\n", + "Epoch 137/170 - loss=0.77764201, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47303075, MSE_maskV_-1.0=0.77679676, val_loss=0.84220147, val_CC_maskV_-1.0=0.45290288, val_MSE_maskV_-1.0=0.83868605, learning_rate=0.001\n", + "Epoch 154/170 - loss=0.77229059, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47832119, MSE_maskV_-1.0=0.77201366, val_loss=0.82635754, val_CC_maskV_-1.0=0.46600008, val_MSE_maskV_-1.0=0.82301271, learning_rate=0.001\n", + "Epoch 170/170 - loss=0.7673496, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48428929, MSE_maskV_-1.0=0.76682413, val_loss=0.83352691, val_CC_maskV_-1.0=0.46200967, val_MSE_maskV_-1.0=0.830145, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:26:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 41.54s\n", + "\u001b[32m2025-05-30 12:26:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.81853211)\n", + "\u001b[32m2025-05-30 12:26:22\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 768us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:26:22\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.762, R2_maskV_-1.0=0.238, CC_maskV_-1.0=0.49\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 790us/step\n", + "51/51 [==============================] - 0s 758us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:26:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_ErSV16\" (1/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:26:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_A1HL64U_ErSV16\" (2/16)\n", + "\u001b[32m2025-05-30 12:26:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_A1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:26:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:26:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:26:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:26:23\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:26:23\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:26:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:26:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 80 (stopped at 95 epochs).\n", + "\u001b[32m2025-05-30 12:26:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/96 - loss=rnn_1step_loss=1.0058044, rnn_1step_R2_maskV_-1.0=-0.011194594, rnn_1step_CC_maskV_-1.0=0.017007492, rnn_1step_MSE_maskV_-1.0=1.0058043, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0869043, val_rnn_1step_R2_maskV_-1.0=-0.040128127, val_rnn_1step_CC_maskV_-1.0=0.089716859, learning_rate=0.001\n", + "Epoch 11/96 - loss=rnn_1step_loss=0.82535976, rnn_1step_R2_maskV_-1.0=0.16967644, rnn_1step_CC_maskV_-1.0=0.44900817, rnn_1step_MSE_maskV_-1.0=0.8253597, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91192579, val_rnn_1step_R2_maskV_-1.0=0.12414977, val_rnn_1step_CC_maskV_-1.0=0.3908709, learning_rate=0.001\n", + "Epoch 21/96 - loss=rnn_1step_loss=0.65091515, rnn_1step_R2_maskV_-1.0=0.34296277, rnn_1step_CC_maskV_-1.0=0.59295952, rnn_1step_MSE_maskV_-1.0=0.65091509, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.74803948, val_rnn_1step_R2_maskV_-1.0=0.27783117, val_rnn_1step_CC_maskV_-1.0=0.56059355, learning_rate=0.001\n", + "Epoch 31/96 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.56129724, rnn_1step_R2_maskV_-1.0=0.43125343, rnn_1step_CC_maskV_-1.0=0.66363674, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.67322618, val_rnn_1step_R2_maskV_-1.0=0.34906942, val_rnn_1step_CC_maskV_-1.0=0.6196115, learning_rate=0.001\n", + "Epoch 41/96 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.51606023, rnn_1step_R2_maskV_-1.0=0.47543654, rnn_1step_CC_maskV_-1.0=0.69675732, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61988777, val_rnn_1step_R2_maskV_-1.0=0.40275228, val_rnn_1step_CC_maskV_-1.0=0.65510339, learning_rate=0.001\n", + "Epoch 51/96 - loss=rnn_1step_loss=0.4802756, rnn_1step_R2_maskV_-1.0=0.5111841, rnn_1step_CC_maskV_-1.0=0.72210693, rnn_1step_MSE_maskV_-1.0=0.48027557, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57179022, val_rnn_1step_R2_maskV_-1.0=0.44866961, val_rnn_1step_CC_maskV_-1.0=0.68738419, learning_rate=0.001\n", + "Epoch 61/96 - loss=rnn_1step_loss=0.44789174, rnn_1step_R2_maskV_-1.0=0.54363132, rnn_1step_CC_maskV_-1.0=0.74389452, rnn_1step_MSE_maskV_-1.0=0.44789177, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53547925, val_rnn_1step_R2_maskV_-1.0=0.48387569, val_rnn_1step_CC_maskV_-1.0=0.71088195, learning_rate=0.001\n", + "Epoch 71/96 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42591977, rnn_1step_R2_maskV_-1.0=0.56545115, rnn_1step_CC_maskV_-1.0=0.75852305, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52911824, val_rnn_1step_R2_maskV_-1.0=0.4910304, val_rnn_1step_CC_maskV_-1.0=0.71357155, learning_rate=0.001\n", + "Epoch 81/96 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41920701, rnn_1step_R2_maskV_-1.0=0.57185739, rnn_1step_CC_maskV_-1.0=0.76386988, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5237059, val_rnn_1step_R2_maskV_-1.0=0.49665251, val_rnn_1step_CC_maskV_-1.0=0.71737456, learning_rate=0.001\n", + "Epoch 91/96 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40296063, rnn_1step_R2_maskV_-1.0=0.58786988, rnn_1step_CC_maskV_-1.0=0.7734462, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52470106, val_rnn_1step_R2_maskV_-1.0=0.49543148, val_rnn_1step_CC_maskV_-1.0=0.71769947, learning_rate=0.001\n", + "Epoch 96/96 - loss=rnn_1step_loss=0.39799622, rnn_1step_R2_maskV_-1.0=0.5930149, rnn_1step_CC_maskV_-1.0=0.77666205, rnn_1step_MSE_maskV_-1.0=0.39799619, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5218522, val_rnn_1step_R2_maskV_-1.0=0.49792302, val_rnn_1step_CC_maskV_-1.0=0.72160476, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:26:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.30s\n", + "\u001b[32m2025-05-30 12:26:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:26:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 144 (stopped at 159 epochs).\n", + "\u001b[32m2025-05-30 12:26:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/160 - loss=rnn_1_1step_loss=1.0029818, rnn_1_1step_R2_maskV_-1.0=-0.0084317289, rnn_1_1step_CC_maskV_-1.0=0.075336002, rnn_1_1step_MSE_maskV_-1.0=1.0029819, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0817721, val_rnn_1_1step_R2_maskV_-1.0=-0.035061643, val_rnn_1_1step_CC_maskV_-1.0=0.19040124, learning_rate=0.001\n", + "Epoch 17/160 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.7538957, rnn_1_1step_R2_maskV_-1.0=0.23623797, rnn_1_1step_CC_maskV_-1.0=0.50217485, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.83715135, val_rnn_1_1step_R2_maskV_-1.0=0.20036772, val_rnn_1_1step_CC_maskV_-1.0=0.49230015, learning_rate=0.001\n", + "Epoch 33/160 - loss=rnn_1_1step_loss=0.57220024, rnn_1_1step_R2_maskV_-1.0=0.41956955, rnn_1_1step_CC_maskV_-1.0=0.65549779, rnn_1_1step_MSE_maskV_-1.0=0.57220018, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.67938185, val_rnn_1_1step_R2_maskV_-1.0=0.34438258, val_rnn_1_1step_CC_maskV_-1.0=0.6123814, learning_rate=0.001\n", + "Epoch 49/160 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.5162859, rnn_1_1step_R2_maskV_-1.0=0.47474435, rnn_1_1step_CC_maskV_-1.0=0.69663465, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64019126, val_rnn_1_1step_R2_maskV_-1.0=0.38382578, val_rnn_1_1step_CC_maskV_-1.0=0.64035201, learning_rate=0.001\n", + "Epoch 65/160 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.48386183, rnn_1_1step_R2_maskV_-1.0=0.50655431, rnn_1_1step_CC_maskV_-1.0=0.71946669, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61435193, val_rnn_1_1step_R2_maskV_-1.0=0.40942085, val_rnn_1_1step_CC_maskV_-1.0=0.65837336, learning_rate=0.001\n", + "Epoch 81/160 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.43859136, rnn_1_1step_R2_maskV_-1.0=0.55157334, rnn_1_1step_CC_maskV_-1.0=0.75009668, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58090729, val_rnn_1_1step_R2_maskV_-1.0=0.44332442, val_rnn_1_1step_CC_maskV_-1.0=0.68276733, learning_rate=0.001\n", + "Epoch 97/160 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39291826, rnn_1_1step_R2_maskV_-1.0=0.59833539, rnn_1_1step_CC_maskV_-1.0=0.78001291, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55172777, val_rnn_1_1step_R2_maskV_-1.0=0.47197664, val_rnn_1_1step_CC_maskV_-1.0=0.70106715, learning_rate=0.001\n", + "Epoch 113/160 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36684385, rnn_1_1step_R2_maskV_-1.0=0.62427425, rnn_1_1step_CC_maskV_-1.0=0.79667115, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5244025, val_rnn_1_1step_R2_maskV_-1.0=0.4971647, val_rnn_1_1step_CC_maskV_-1.0=0.71995091, learning_rate=0.001\n", + "Epoch 129/160 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.35595307, rnn_1_1step_R2_maskV_-1.0=0.63468087, rnn_1_1step_CC_maskV_-1.0=0.80394173, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49712512, val_rnn_1_1step_R2_maskV_-1.0=0.52341545, val_rnn_1_1step_CC_maskV_-1.0=0.73775226, learning_rate=0.001\n", + "Epoch 145/160 - loss=rnn_1_1step_loss=0.34334517, rnn_1_1step_R2_maskV_-1.0=0.64777917, rnn_1_1step_CC_maskV_-1.0=0.81207013, rnn_1_1step_MSE_maskV_-1.0=0.34334514, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50151747, val_rnn_1_1step_R2_maskV_-1.0=0.52050573, val_rnn_1_1step_CC_maskV_-1.0=0.73871821, learning_rate=0.001\n", + "Epoch 160/160 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33128676, rnn_1_1step_R2_maskV_-1.0=0.66049987, rnn_1_1step_CC_maskV_-1.0=0.8192578, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50249749, val_rnn_1_1step_R2_maskV_-1.0=0.52056819, val_rnn_1_1step_CC_maskV_-1.0=0.74009055, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:26:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 19.45s\n", + "\u001b[32m2025-05-30 12:26:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.48486781)\n", + "\u001b[32m2025-05-30 12:26:58\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.312, R2_maskV_-1.0=0.688, CC_maskV_-1.0=0.83\n", + "\u001b[32m2025-05-30 12:26:59\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.459, R2_maskV_-1.0=0.551, CC_maskV_-1.0=0.757\n", + "\u001b[32m2025-05-30 12:26:59\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:26:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:27:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 101 (stopped at 116 epochs).\n", + "\u001b[32m2025-05-30 12:27:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/117 - loss=2.4117222, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.05489587, MSE_maskV_-1.0=2.4093792, val_loss=1.2594316, val_CC_maskV_-1.0=0.11940223, val_MSE_maskV_-1.0=1.2512387, learning_rate=0.001\n", + "Epoch 13/117 - loss=0.81918979, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42676464, MSE_maskV_-1.0=0.81846046, val_loss=0.87689435, val_CC_maskV_-1.0=0.40682402, val_MSE_maskV_-1.0=0.87320846, learning_rate=0.001\n", + "Epoch 25/117 - loss=0.77710646, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47379446, MSE_maskV_-1.0=0.77668947, val_loss=0.83422691, val_CC_maskV_-1.0=0.45230526, val_MSE_maskV_-1.0=0.83031666, learning_rate=0.001\n", + "Epoch 37/117 - loss=0.75914878, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49187091, MSE_maskV_-1.0=0.75922883, val_loss=0.81245601, val_CC_maskV_-1.0=0.47233006, val_MSE_maskV_-1.0=0.80841702, learning_rate=0.001\n", + "Epoch 49/117 - loss=0.75000876, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50055718, MSE_maskV_-1.0=0.74967438, val_loss=0.80088991, val_CC_maskV_-1.0=0.48217249, val_MSE_maskV_-1.0=0.79682428, learning_rate=0.001\n", + "Epoch 61/117 - loss=0.7445839, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5049578, MSE_maskV_-1.0=0.74468267, val_loss=0.79637104, val_CC_maskV_-1.0=0.4864566, val_MSE_maskV_-1.0=0.79222631, learning_rate=0.001\n", + "Epoch 73/117 - loss=0.74182284, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50755066, MSE_maskV_-1.0=0.74157029, val_loss=0.79457307, val_CC_maskV_-1.0=0.487647, val_MSE_maskV_-1.0=0.79038388, learning_rate=0.001\n", + "Epoch 85/117 - loss=0.74004161, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50913018, MSE_maskV_-1.0=0.74039, val_loss=0.79141897, val_CC_maskV_-1.0=0.49013475, val_MSE_maskV_-1.0=0.78727782, learning_rate=0.001\n", + "Epoch 97/117 - loss=0.73841566, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51112455, MSE_maskV_-1.0=0.7382254, val_loss=0.78916746, val_CC_maskV_-1.0=0.49257001, val_MSE_maskV_-1.0=0.78484839, learning_rate=0.001\n", + "Epoch 109/117 - loss=0.73783714, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5115214, MSE_maskV_-1.0=0.73763341, val_loss=0.78881258, val_CC_maskV_-1.0=0.49262673, val_MSE_maskV_-1.0=0.78460848, learning_rate=0.001\n", + "Epoch 117/117 - loss=0.73732466, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51172042, MSE_maskV_-1.0=0.73712546, val_loss=0.79232383, val_CC_maskV_-1.0=0.4887327, val_MSE_maskV_-1.0=0.78813076, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:27:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 29.68s\n", + "\u001b[32m2025-05-30 12:27:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:27:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 101 (stopped at 116 epochs).\n", + "\u001b[32m2025-05-30 12:27:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/117 - loss=2.7236636, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.022563681, MSE_maskV_-1.0=2.7204347, val_loss=1.3170956, val_CC_maskV_-1.0=0.053554311, val_MSE_maskV_-1.0=1.3053186, learning_rate=0.001\n", + "Epoch 13/117 - loss=0.82617813, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41861653, MSE_maskV_-1.0=0.82546967, val_loss=0.88424128, val_CC_maskV_-1.0=0.40178126, val_MSE_maskV_-1.0=0.87916863, learning_rate=0.001\n", + "Epoch 25/117 - loss=0.77927136, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47197658, MSE_maskV_-1.0=0.77881277, val_loss=0.83566755, val_CC_maskV_-1.0=0.45222306, val_MSE_maskV_-1.0=0.83100128, learning_rate=0.001\n", + "Epoch 37/117 - loss=0.7597506, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49151745, MSE_maskV_-1.0=0.75984931, val_loss=0.81218016, val_CC_maskV_-1.0=0.47305095, val_MSE_maskV_-1.0=0.8076911, learning_rate=0.001\n", + "Epoch 49/117 - loss=0.75012296, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50055337, MSE_maskV_-1.0=0.74981362, val_loss=0.80001152, val_CC_maskV_-1.0=0.48304188, val_MSE_maskV_-1.0=0.79562742, learning_rate=0.001\n", + "Epoch 61/117 - loss=0.74456173, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50503653, MSE_maskV_-1.0=0.74467635, val_loss=0.79551518, val_CC_maskV_-1.0=0.48704311, val_MSE_maskV_-1.0=0.79114002, learning_rate=0.001\n", + "Epoch 73/117 - loss=0.74175882, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50760764, MSE_maskV_-1.0=0.74149889, val_loss=0.79388076, val_CC_maskV_-1.0=0.48803523, val_MSE_maskV_-1.0=0.7895366, learning_rate=0.001\n", + "Epoch 85/117 - loss=0.739999, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50915521, MSE_maskV_-1.0=0.74034232, val_loss=0.79073375, val_CC_maskV_-1.0=0.49048677, val_MSE_maskV_-1.0=0.7864759, learning_rate=0.001\n", + "Epoch 97/117 - loss=0.73837912, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51116878, MSE_maskV_-1.0=0.73818809, val_loss=0.78855973, val_CC_maskV_-1.0=0.49287924, val_MSE_maskV_-1.0=0.78416157, learning_rate=0.001\n", + "Epoch 109/117 - loss=0.73782074, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51152587, MSE_maskV_-1.0=0.73760992, val_loss=0.7883411, val_CC_maskV_-1.0=0.49280018, val_MSE_maskV_-1.0=0.78407913, learning_rate=0.001\n", + "Epoch 117/117 - loss=0.73731452, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51172322, MSE_maskV_-1.0=0.7371152, val_loss=0.79187208, val_CC_maskV_-1.0=0.48889175, val_MSE_maskV_-1.0=0.78763264, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:27:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 29.25s\n", + "\u001b[32m2025-05-30 12:27:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.78761631)\n", + "\u001b[32m2025-05-30 12:27:58\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 763us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:27:58\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.737, R2_maskV_-1.0=0.264, CC_maskV_-1.0=0.514\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 767us/step\n", + "51/51 [==============================] - 0s 722us/step\n", + "84/84 [==============================] - 0s 1ms/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:27:59\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_A1HL64U_ErSV16\" (2/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_A1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:27:59\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_K1HL64U_ErSV16\" (3/16)\n", + "\u001b[32m2025-05-30 12:27:59\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_K1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:27:59\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:27:59\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:27:59\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:27:59\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:27:59\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:27:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:28:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 89 (stopped at 104 epochs).\n", + "\u001b[32m2025-05-30 12:28:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.005004, rnn_1step_R2_maskV_-1.0=-0.010377344, rnn_1step_CC_maskV_-1.0=0.12225543, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0878692, val_rnn_1step_R2_maskV_-1.0=-0.04079257, val_rnn_1step_CC_maskV_-1.0=0.30325022, learning_rate=0.001\n", + "Epoch 12/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.79504085, rnn_1step_R2_maskV_-1.0=0.19541293, rnn_1step_CC_maskV_-1.0=0.4580625, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.86158824, val_rnn_1step_R2_maskV_-1.0=0.17435238, val_rnn_1step_CC_maskV_-1.0=0.46472842, learning_rate=0.001\n", + "Epoch 23/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.57073528, rnn_1step_R2_maskV_-1.0=0.42112416, rnn_1step_CC_maskV_-1.0=0.65684295, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.66020542, val_rnn_1step_R2_maskV_-1.0=0.36190641, val_rnn_1step_CC_maskV_-1.0=0.62590909, learning_rate=0.001\n", + "Epoch 34/105 - loss=rnn_1step_loss=0.47572491, rnn_1step_R2_maskV_-1.0=0.51685822, rnn_1step_CC_maskV_-1.0=0.72509819, rnn_1step_MSE_maskV_-1.0=0.47572488, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59025079, val_rnn_1step_R2_maskV_-1.0=0.43082744, val_rnn_1step_CC_maskV_-1.0=0.67357308, learning_rate=0.001\n", + "Epoch 45/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39706489, rnn_1step_R2_maskV_-1.0=0.59609509, rnn_1step_CC_maskV_-1.0=0.7777617, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52629977, val_rnn_1step_R2_maskV_-1.0=0.4949761, val_rnn_1step_CC_maskV_-1.0=0.7151565, learning_rate=0.001\n", + "Epoch 56/105 - loss=rnn_1step_loss=0.3513082, rnn_1step_R2_maskV_-1.0=0.64285648, rnn_1step_CC_maskV_-1.0=0.80674881, rnn_1step_MSE_maskV_-1.0=0.35130817, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49475396, val_rnn_1step_R2_maskV_-1.0=0.52530217, val_rnn_1step_CC_maskV_-1.0=0.73571968, learning_rate=0.001\n", + "Epoch 67/105 - loss=rnn_1step_loss=0.29012725, rnn_1step_R2_maskV_-1.0=0.70537806, rnn_1step_CC_maskV_-1.0=0.84387791, rnn_1step_MSE_maskV_-1.0=0.29012722, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44885564, val_rnn_1step_R2_maskV_-1.0=0.56886518, val_rnn_1step_CC_maskV_-1.0=0.76487917, learning_rate=0.001\n", + "Epoch 78/105 - loss=rnn_1step_loss=0.26305741, rnn_1step_R2_maskV_-1.0=0.73292875, rnn_1step_CC_maskV_-1.0=0.85967159, rnn_1step_MSE_maskV_-1.0=0.26305744, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4357489, val_rnn_1step_R2_maskV_-1.0=0.5810746, val_rnn_1step_CC_maskV_-1.0=0.77233243, learning_rate=0.001\n", + "Epoch 89/105 - loss=rnn_1step_loss=0.24984597, rnn_1step_R2_maskV_-1.0=0.74615449, rnn_1step_CC_maskV_-1.0=0.86723179, rnn_1step_MSE_maskV_-1.0=0.24984595, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.43360174, val_rnn_1step_R2_maskV_-1.0=0.58294243, val_rnn_1step_CC_maskV_-1.0=0.77371538, learning_rate=0.001\n", + "Epoch 100/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.2529954, rnn_1step_R2_maskV_-1.0=0.74269307, rnn_1step_CC_maskV_-1.0=0.8659237, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45928839, val_rnn_1step_R2_maskV_-1.0=0.55636775, val_rnn_1step_CC_maskV_-1.0=0.75954688, learning_rate=0.001\n", + "Epoch 105/105 - loss=rnn_1step_loss=0.24226467, rnn_1step_R2_maskV_-1.0=0.75317472, rnn_1step_CC_maskV_-1.0=0.87218821, rnn_1step_MSE_maskV_-1.0=0.24226466, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44136238, val_rnn_1step_R2_maskV_-1.0=0.57567406, val_rnn_1step_CC_maskV_-1.0=0.77034903, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:28:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 11.68s\n", + "\u001b[32m2025-05-30 12:28:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:28:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 95 (stopped at 110 epochs).\n", + "\u001b[32m2025-05-30 12:28:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/111 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0058357, rnn_1_1step_R2_maskV_-1.0=-0.011258271, rnn_1_1step_CC_maskV_-1.0=0.019730436, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0896703, val_rnn_1_1step_R2_maskV_-1.0=-0.042622149, val_rnn_1_1step_CC_maskV_-1.0=0.23964256, learning_rate=0.001\n", + "Epoch 13/111 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.79800183, rnn_1_1step_R2_maskV_-1.0=0.19134542, rnn_1_1step_CC_maskV_-1.0=0.45447594, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.87064791, val_rnn_1_1step_R2_maskV_-1.0=0.16707644, val_rnn_1_1step_CC_maskV_-1.0=0.4594878, learning_rate=0.001\n", + "Epoch 25/111 - loss=rnn_1_1step_loss=0.55168575, rnn_1_1step_R2_maskV_-1.0=0.43927723, rnn_1_1step_CC_maskV_-1.0=0.67084867, rnn_1_1step_MSE_maskV_-1.0=0.55168569, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65199012, val_rnn_1_1step_R2_maskV_-1.0=0.37438291, val_rnn_1_1step_CC_maskV_-1.0=0.63142592, learning_rate=0.001\n", + "Epoch 37/111 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.4468281, rnn_1_1step_R2_maskV_-1.0=0.54426384, rnn_1_1step_CC_maskV_-1.0=0.74497378, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5171836, val_rnn_1_1step_R2_maskV_-1.0=0.50562578, val_rnn_1_1step_CC_maskV_-1.0=0.72202605, learning_rate=0.001\n", + "Epoch 49/111 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38889602, rnn_1_1step_R2_maskV_-1.0=0.60336155, rnn_1_1step_CC_maskV_-1.0=0.78295016, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46696272, val_rnn_1_1step_R2_maskV_-1.0=0.55404711, val_rnn_1_1step_CC_maskV_-1.0=0.75285089, learning_rate=0.001\n", + "Epoch 61/111 - loss=rnn_1_1step_loss=0.34668979, rnn_1_1step_R2_maskV_-1.0=0.64711183, rnn_1_1step_CC_maskV_-1.0=0.80949801, rnn_1_1step_MSE_maskV_-1.0=0.34668973, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45086887, val_rnn_1_1step_R2_maskV_-1.0=0.56982619, val_rnn_1_1step_CC_maskV_-1.0=0.76254535, learning_rate=0.001\n", + "Epoch 73/111 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30091685, rnn_1_1step_R2_maskV_-1.0=0.69438416, rnn_1_1step_CC_maskV_-1.0=0.8373996, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.43434429, val_rnn_1_1step_R2_maskV_-1.0=0.58518326, val_rnn_1_1step_CC_maskV_-1.0=0.77276647, learning_rate=0.001\n", + "Epoch 85/111 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.2626369, rnn_1_1step_R2_maskV_-1.0=0.73310131, rnn_1_1step_CC_maskV_-1.0=0.85995018, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41761065, val_rnn_1_1step_R2_maskV_-1.0=0.59990203, val_rnn_1_1step_CC_maskV_-1.0=0.78265595, learning_rate=0.001\n", + "Epoch 97/111 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.25174907, rnn_1_1step_R2_maskV_-1.0=0.74321944, rnn_1_1step_CC_maskV_-1.0=0.8662203, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.43180808, val_rnn_1_1step_R2_maskV_-1.0=0.58689159, val_rnn_1_1step_CC_maskV_-1.0=0.77726471, learning_rate=0.001\n", + "Epoch 109/111 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.22415172, rnn_1_1step_R2_maskV_-1.0=0.77175605, rnn_1_1step_CC_maskV_-1.0=0.88175917, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41588965, val_rnn_1_1step_R2_maskV_-1.0=0.60108912, val_rnn_1_1step_CC_maskV_-1.0=0.78440094, learning_rate=0.001\n", + "Epoch 111/111 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.22335298, rnn_1_1step_R2_maskV_-1.0=0.77272308, rnn_1_1step_CC_maskV_-1.0=0.88221687, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41702756, val_rnn_1_1step_R2_maskV_-1.0=0.59984183, val_rnn_1_1step_CC_maskV_-1.0=0.78330982, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:28:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.10s\n", + "\u001b[32m2025-05-30 12:28:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.41052374)\n", + "\u001b[32m2025-05-30 12:28:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.214, R2_maskV_-1.0=0.786, CC_maskV_-1.0=0.887\n", + "\u001b[32m2025-05-30 12:28:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.388, R2_maskV_-1.0=0.62, CC_maskV_-1.0=0.796\n", + "\u001b[32m2025-05-30 12:28:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:28:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:29:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 363 (stopped at 378 epochs).\n", + "\u001b[32m2025-05-30 12:29:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/379 - loss=1.5397626, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.049134899, MSE_maskV_-1.0=1.5393555, val_loss=1.0964985, val_CC_maskV_-1.0=0.10059698, val_MSE_maskV_-1.0=1.0898358, learning_rate=0.001\n", + "Epoch 39/379 - loss=0.89079648, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3342182, MSE_maskV_-1.0=0.89034915, val_loss=0.96530563, val_CC_maskV_-1.0=0.30155706, val_MSE_maskV_-1.0=0.96079171, learning_rate=0.001\n", + "Epoch 77/379 - loss=0.86946988, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36623868, MSE_maskV_-1.0=0.86963558, val_loss=0.94116902, val_CC_maskV_-1.0=0.33945113, val_MSE_maskV_-1.0=0.93677723, learning_rate=0.001\n", + "Epoch 115/379 - loss=0.85683209, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38301325, MSE_maskV_-1.0=0.85617125, val_loss=0.9278397, val_CC_maskV_-1.0=0.35809588, val_MSE_maskV_-1.0=0.92349631, learning_rate=0.001\n", + "Epoch 153/379 - loss=0.84691674, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39624593, MSE_maskV_-1.0=0.84688222, val_loss=0.91803831, val_CC_maskV_-1.0=0.37099418, val_MSE_maskV_-1.0=0.91386229, learning_rate=0.001\n", + "Epoch 191/379 - loss=0.84021467, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40375376, MSE_maskV_-1.0=0.84002793, val_loss=0.91021037, val_CC_maskV_-1.0=0.38098097, val_MSE_maskV_-1.0=0.90607297, learning_rate=0.001\n", + "Epoch 229/379 - loss=0.8345387, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41139004, MSE_maskV_-1.0=0.83389539, val_loss=0.90494508, val_CC_maskV_-1.0=0.38762081, val_MSE_maskV_-1.0=0.9009636, learning_rate=0.001\n", + "Epoch 267/379 - loss=0.82995355, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4163031, MSE_maskV_-1.0=0.8294788, val_loss=0.90068972, val_CC_maskV_-1.0=0.39213756, val_MSE_maskV_-1.0=0.8964175, learning_rate=0.001\n", + "Epoch 305/379 - loss=0.82618415, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42063728, MSE_maskV_-1.0=0.82533073, val_loss=0.89709032, val_CC_maskV_-1.0=0.39617613, val_MSE_maskV_-1.0=0.89298886, learning_rate=0.001\n", + "Epoch 343/379 - loss=0.82321066, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4243575, MSE_maskV_-1.0=0.82279634, val_loss=0.89211071, val_CC_maskV_-1.0=0.40296626, val_MSE_maskV_-1.0=0.88790303, learning_rate=0.001\n", + "Epoch 379/379 - loss=0.82096034, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42602056, MSE_maskV_-1.0=0.82063699, val_loss=0.89051539, val_CC_maskV_-1.0=0.40456638, val_MSE_maskV_-1.0=0.88654763, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:29:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 92.54s\n", + "\u001b[32m2025-05-30 12:29:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:31:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 363 (stopped at 378 epochs).\n", + "\u001b[32m2025-05-30 12:31:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/379 - loss=1.7065934, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.039091714, MSE_maskV_-1.0=1.7057679, val_loss=1.1134785, val_CC_maskV_-1.0=0.084908068, val_MSE_maskV_-1.0=1.1078711, learning_rate=0.001\n", + "Epoch 39/379 - loss=0.88886279, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.33735335, MSE_maskV_-1.0=0.88842165, val_loss=0.9626767, val_CC_maskV_-1.0=0.3064169, val_MSE_maskV_-1.0=0.95797652, learning_rate=0.001\n", + "Epoch 77/379 - loss=0.86772799, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36889824, MSE_maskV_-1.0=0.86787808, val_loss=0.9392792, val_CC_maskV_-1.0=0.34284753, val_MSE_maskV_-1.0=0.93476021, learning_rate=0.001\n", + "Epoch 115/379 - loss=0.85534561, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38507095, MSE_maskV_-1.0=0.85470003, val_loss=0.9264065, val_CC_maskV_-1.0=0.36058164, val_MSE_maskV_-1.0=0.92197222, learning_rate=0.001\n", + "Epoch 153/379 - loss=0.8456285, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39799675, MSE_maskV_-1.0=0.84558356, val_loss=0.9168635, val_CC_maskV_-1.0=0.37294811, val_MSE_maskV_-1.0=0.91260993, learning_rate=0.001\n", + "Epoch 191/379 - loss=0.83910578, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40520766, MSE_maskV_-1.0=0.83892775, val_loss=0.90931284, val_CC_maskV_-1.0=0.38247389, val_MSE_maskV_-1.0=0.90510494, learning_rate=0.001\n", + "Epoch 229/379 - loss=0.83356476, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41261998, MSE_maskV_-1.0=0.83292037, val_loss=0.90414858, val_CC_maskV_-1.0=0.38891324, val_MSE_maskV_-1.0=0.90012056, learning_rate=0.001\n", + "Epoch 267/379 - loss=0.82909232, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4173713, MSE_maskV_-1.0=0.82862651, val_loss=0.90012252, val_CC_maskV_-1.0=0.39310452, val_MSE_maskV_-1.0=0.89581233, learning_rate=0.001\n", + "Epoch 305/379 - loss=0.82543427, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42155266, MSE_maskV_-1.0=0.82457554, val_loss=0.89656472, val_CC_maskV_-1.0=0.39705119, val_MSE_maskV_-1.0=0.89243472, learning_rate=0.001\n", + "Epoch 343/379 - loss=0.82255083, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42514455, MSE_maskV_-1.0=0.82213634, val_loss=0.89167202, val_CC_maskV_-1.0=0.40369755, val_MSE_maskV_-1.0=0.8874442, learning_rate=0.001\n", + "Epoch 379/379 - loss=0.82035851, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4267011, MSE_maskV_-1.0=0.82003653, val_loss=0.89016467, val_CC_maskV_-1.0=0.40515, val_MSE_maskV_-1.0=0.88618469, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:31:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 91.80s\n", + "\u001b[32m2025-05-30 12:31:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.88873917)\n", + "\u001b[32m2025-05-30 12:31:29\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 714us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:31:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.82, R2_maskV_-1.0=0.179, CC_maskV_-1.0=0.428\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 862us/step\n", + "51/51 [==============================] - 0s 760us/step\n", + "84/84 [==============================] - 0s 716us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:31:30\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_K1HL64U_ErSV16\" (3/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_K1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:31:30\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_Cz1HL64U_ErSV16\" (4/16)\n", + "\u001b[32m2025-05-30 12:31:30\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_Cz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:31:30\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:31:30\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:31:30\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:31:30\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:31:30\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:31:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:31:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 262 (stopped at 277 epochs).\n", + "\u001b[32m2025-05-30 12:31:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/278 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0049903, rnn_1step_R2_maskV_-1.0=-0.010403555, rnn_1step_CC_maskV_-1.0=0.11948185, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0884852, val_rnn_1step_R2_maskV_-1.0=-0.041486174, val_rnn_1step_CC_maskV_-1.0=0.2715219, learning_rate=0.001\n", + "Epoch 29/278 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.58813792, rnn_1step_R2_maskV_-1.0=0.40455863, rnn_1step_CC_maskV_-1.0=0.64342874, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.67758417, val_rnn_1step_R2_maskV_-1.0=0.34741986, val_rnn_1step_CC_maskV_-1.0=0.61410797, learning_rate=0.001\n", + "Epoch 57/278 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.43463913, rnn_1step_R2_maskV_-1.0=0.55629909, rnn_1step_CC_maskV_-1.0=0.75340325, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46866015, val_rnn_1step_R2_maskV_-1.0=0.54940796, val_rnn_1step_CC_maskV_-1.0=0.75449693, learning_rate=0.001\n", + "Epoch 85/278 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40627027, rnn_1step_R2_maskV_-1.0=0.58453286, rnn_1step_CC_maskV_-1.0=0.77199924, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45153221, val_rnn_1step_R2_maskV_-1.0=0.56522399, val_rnn_1step_CC_maskV_-1.0=0.76454574, learning_rate=0.001\n", + "Epoch 113/278 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38153037, rnn_1step_R2_maskV_-1.0=0.60980642, rnn_1step_CC_maskV_-1.0=0.78788173, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44486037, val_rnn_1step_R2_maskV_-1.0=0.57122123, val_rnn_1step_CC_maskV_-1.0=0.76822281, learning_rate=0.001\n", + "Epoch 141/278 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35564372, rnn_1step_R2_maskV_-1.0=0.63656008, rnn_1step_CC_maskV_-1.0=0.8040849, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.43371952, val_rnn_1step_R2_maskV_-1.0=0.58254224, val_rnn_1step_CC_maskV_-1.0=0.77433896, learning_rate=0.001\n", + "Epoch 169/278 - loss=rnn_1step_loss=0.34235087, rnn_1step_R2_maskV_-1.0=0.64982712, rnn_1step_CC_maskV_-1.0=0.81230956, rnn_1step_MSE_maskV_-1.0=0.34235093, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42084911, val_rnn_1step_R2_maskV_-1.0=0.59563112, val_rnn_1step_CC_maskV_-1.0=0.78188103, learning_rate=0.001\n", + "Epoch 197/278 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33531666, rnn_1step_R2_maskV_-1.0=0.65668184, rnn_1step_CC_maskV_-1.0=0.8166253, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.41264287, val_rnn_1step_R2_maskV_-1.0=0.60385925, val_rnn_1step_CC_maskV_-1.0=0.78655869, learning_rate=0.001\n", + "Epoch 225/278 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32970622, rnn_1step_R2_maskV_-1.0=0.6622315, rnn_1step_CC_maskV_-1.0=0.82000792, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4071928, val_rnn_1step_R2_maskV_-1.0=0.60936862, val_rnn_1step_CC_maskV_-1.0=0.78959805, learning_rate=0.001\n", + "Epoch 253/278 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32481325, rnn_1step_R2_maskV_-1.0=0.66701174, rnn_1step_CC_maskV_-1.0=0.82294798, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.40348944, val_rnn_1step_R2_maskV_-1.0=0.61302149, val_rnn_1step_CC_maskV_-1.0=0.79166186, learning_rate=0.001\n", + "Epoch 278/278 - loss=rnn_1step_loss=0.32109961, rnn_1step_R2_maskV_-1.0=0.67066067, rnn_1step_CC_maskV_-1.0=0.82515234, rnn_1step_MSE_maskV_-1.0=0.32109964, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.40410605, val_rnn_1step_R2_maskV_-1.0=0.61242604, val_rnn_1step_CC_maskV_-1.0=0.79112267, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:31:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 28.09s\n", + "\u001b[32m2025-05-30 12:31:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:32:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 378 (stopped at 393 epochs).\n", + "\u001b[32m2025-05-30 12:32:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/394 - loss=rnn_1_1step_loss=1.0051804, rnn_1_1step_R2_maskV_-1.0=-0.010566823, rnn_1_1step_CC_maskV_-1.0=0.10124296, rnn_1_1step_MSE_maskV_-1.0=1.0051802, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0885521, val_rnn_1_1step_R2_maskV_-1.0=-0.041500315, val_rnn_1_1step_CC_maskV_-1.0=0.28205293, learning_rate=0.001\n", + "Epoch 41/394 - loss=rnn_1_1step_loss=0.51439029, rnn_1_1step_R2_maskV_-1.0=0.47800803, rnn_1_1step_CC_maskV_-1.0=0.69860291, rnn_1_1step_MSE_maskV_-1.0=0.51439023, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57916719, val_rnn_1_1step_R2_maskV_-1.0=0.44189581, val_rnn_1_1step_CC_maskV_-1.0=0.68223816, learning_rate=0.001\n", + "Epoch 81/394 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41574439, rnn_1_1step_R2_maskV_-1.0=0.57483548, rnn_1_1step_CC_maskV_-1.0=0.76587188, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.44808802, val_rnn_1_1step_R2_maskV_-1.0=0.56923169, val_rnn_1_1step_CC_maskV_-1.0=0.76639497, learning_rate=0.001\n", + "Epoch 121/394 - loss=rnn_1_1step_loss=0.39209518, rnn_1_1step_R2_maskV_-1.0=0.59876275, rnn_1_1step_CC_maskV_-1.0=0.78106177, rnn_1_1step_MSE_maskV_-1.0=0.39209515, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.44200358, val_rnn_1_1step_R2_maskV_-1.0=0.57422185, val_rnn_1_1step_CC_maskV_-1.0=0.76958477, learning_rate=0.001\n", + "Epoch 161/394 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.3703196, rnn_1_1step_R2_maskV_-1.0=0.6214456, rnn_1_1step_CC_maskV_-1.0=0.79495639, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.43482748, val_rnn_1_1step_R2_maskV_-1.0=0.58098346, val_rnn_1_1step_CC_maskV_-1.0=0.7737959, learning_rate=0.001\n", + "Epoch 201/394 - loss=rnn_1_1step_loss=0.34879127, rnn_1_1step_R2_maskV_-1.0=0.64368039, rnn_1_1step_CC_maskV_-1.0=0.80844784, rnn_1_1step_MSE_maskV_-1.0=0.3487913, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4243722, val_rnn_1_1step_R2_maskV_-1.0=0.59153426, val_rnn_1_1step_CC_maskV_-1.0=0.77964115, learning_rate=0.001\n", + "Epoch 241/394 - loss=rnn_1_1step_loss=0.33214077, rnn_1_1step_R2_maskV_-1.0=0.66042006, rnn_1_1step_CC_maskV_-1.0=0.81874704, rnn_1_1step_MSE_maskV_-1.0=0.33214074, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41596782, val_rnn_1_1step_R2_maskV_-1.0=0.60007656, val_rnn_1_1step_CC_maskV_-1.0=0.7842831, learning_rate=0.001\n", + "Epoch 281/394 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31948483, rnn_1_1step_R2_maskV_-1.0=0.67287219, rnn_1_1step_CC_maskV_-1.0=0.82646, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.40810934, val_rnn_1_1step_R2_maskV_-1.0=0.60755885, val_rnn_1_1step_CC_maskV_-1.0=0.78859043, learning_rate=0.001\n", + "Epoch 321/394 - loss=rnn_1_1step_loss=0.30949187, rnn_1_1step_R2_maskV_-1.0=0.6826911, rnn_1_1step_CC_maskV_-1.0=0.83238602, rnn_1_1step_MSE_maskV_-1.0=0.3094919, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4013283, val_rnn_1_1step_R2_maskV_-1.0=0.61412549, val_rnn_1_1step_CC_maskV_-1.0=0.7923134, learning_rate=0.001\n", + "Epoch 361/394 - loss=rnn_1_1step_loss=0.30106941, rnn_1_1step_R2_maskV_-1.0=0.69105154, rnn_1_1step_CC_maskV_-1.0=0.83724105, rnn_1_1step_MSE_maskV_-1.0=0.30106938, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.39862585, val_rnn_1_1step_R2_maskV_-1.0=0.61682522, val_rnn_1_1step_CC_maskV_-1.0=0.79393363, learning_rate=0.001\n", + "Epoch 394/394 - loss=rnn_1_1step_loss=0.29528823, rnn_1_1step_R2_maskV_-1.0=0.6969229, rnn_1_1step_CC_maskV_-1.0=0.84065902, rnn_1_1step_MSE_maskV_-1.0=0.29528821, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4002243, val_rnn_1_1step_R2_maskV_-1.0=0.6152215, val_rnn_1_1step_CC_maskV_-1.0=0.79291838, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:32:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 39.04s\n", + "\u001b[32m2025-05-30 12:32:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.3979868)\n", + "\u001b[32m2025-05-30 12:32:38\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.265, R2_maskV_-1.0=0.735, CC_maskV_-1.0=0.857\n", + "\u001b[32m2025-05-30 12:32:39\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.38, R2_maskV_-1.0=0.626, CC_maskV_-1.0=0.801\n", + "\u001b[32m2025-05-30 12:32:39\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:32:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:33:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 128 (stopped at 143 epochs).\n", + "\u001b[32m2025-05-30 12:33:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/144 - loss=10.56354, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=-0.0059529385, MSE_maskV_-1.0=10.540351, val_loss=2.7311177, val_CC_maskV_-1.0=-0.015802002, val_MSE_maskV_-1.0=2.7303817, learning_rate=0.001\n", + "Epoch 16/144 - loss=0.85280734, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39097482, MSE_maskV_-1.0=0.85286874, val_loss=0.91926444, val_CC_maskV_-1.0=0.36788929, val_MSE_maskV_-1.0=0.91581452, learning_rate=0.001\n", + "Epoch 31/144 - loss=0.78412133, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46523649, MSE_maskV_-1.0=0.78381908, val_loss=0.85292584, val_CC_maskV_-1.0=0.43917084, val_MSE_maskV_-1.0=0.84943533, learning_rate=0.001\n", + "Epoch 46/144 - loss=0.75829583, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49125597, MSE_maskV_-1.0=0.75874692, val_loss=0.82265317, val_CC_maskV_-1.0=0.46826771, val_MSE_maskV_-1.0=0.81879681, learning_rate=0.001\n", + "Epoch 61/144 - loss=0.7448889, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50459343, MSE_maskV_-1.0=0.74490476, val_loss=0.80522478, val_CC_maskV_-1.0=0.4849014, val_MSE_maskV_-1.0=0.80118614, learning_rate=0.001\n", + "Epoch 76/144 - loss=0.73776835, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51182646, MSE_maskV_-1.0=0.73794407, val_loss=0.79810113, val_CC_maskV_-1.0=0.49415395, val_MSE_maskV_-1.0=0.79412818, learning_rate=0.001\n", + "Epoch 91/144 - loss=0.73122758, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51820523, MSE_maskV_-1.0=0.73127729, val_loss=0.78982842, val_CC_maskV_-1.0=0.49849865, val_MSE_maskV_-1.0=0.78563982, learning_rate=0.001\n", + "Epoch 106/144 - loss=0.7276386, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5217191, MSE_maskV_-1.0=0.72755802, val_loss=0.79351306, val_CC_maskV_-1.0=0.49826077, val_MSE_maskV_-1.0=0.78935242, learning_rate=0.001\n", + "Epoch 121/144 - loss=0.72539473, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52392638, MSE_maskV_-1.0=0.72590148, val_loss=0.78286165, val_CC_maskV_-1.0=0.50638336, val_MSE_maskV_-1.0=0.77885181, learning_rate=0.001\n", + "Epoch 136/144 - loss=0.72381717, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52570444, MSE_maskV_-1.0=0.72368479, val_loss=0.7776792, val_CC_maskV_-1.0=0.50981259, val_MSE_maskV_-1.0=0.77385807, learning_rate=0.001\n", + "Epoch 144/144 - loss=0.72205108, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52755743, MSE_maskV_-1.0=0.72170067, val_loss=0.77892429, val_CC_maskV_-1.0=0.50966233, val_MSE_maskV_-1.0=0.7746712, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:33:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 35.72s\n", + "\u001b[32m2025-05-30 12:33:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:33:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 128 (stopped at 143 epochs).\n", + "\u001b[32m2025-05-30 12:33:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/144 - loss=15.352441, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0014305352, MSE_maskV_-1.0=15.313068, val_loss=2.4536548, val_CC_maskV_-1.0=0.030540036, val_MSE_maskV_-1.0=2.4470797, learning_rate=0.001\n", + "Epoch 16/144 - loss=0.85977268, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38384777, MSE_maskV_-1.0=0.8598395, val_loss=0.92338181, val_CC_maskV_-1.0=0.36824536, val_MSE_maskV_-1.0=0.91927123, learning_rate=0.001\n", + "Epoch 31/144 - loss=0.78502119, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46408081, MSE_maskV_-1.0=0.78471959, val_loss=0.85192376, val_CC_maskV_-1.0=0.44133392, val_MSE_maskV_-1.0=0.84824628, learning_rate=0.001\n", + "Epoch 46/144 - loss=0.75832045, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49111956, MSE_maskV_-1.0=0.7588259, val_loss=0.81915522, val_CC_maskV_-1.0=0.47207949, val_MSE_maskV_-1.0=0.81521469, learning_rate=0.001\n", + "Epoch 61/144 - loss=0.7448163, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50466168, MSE_maskV_-1.0=0.74485463, val_loss=0.80084538, val_CC_maskV_-1.0=0.48883778, val_MSE_maskV_-1.0=0.79684293, learning_rate=0.001\n", + "Epoch 76/144 - loss=0.73777771, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51183772, MSE_maskV_-1.0=0.73793113, val_loss=0.79457897, val_CC_maskV_-1.0=0.49691454, val_MSE_maskV_-1.0=0.79066318, learning_rate=0.001\n", + "Epoch 91/144 - loss=0.73114407, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51831657, MSE_maskV_-1.0=0.731161, val_loss=0.78688204, val_CC_maskV_-1.0=0.50092107, val_MSE_maskV_-1.0=0.78277206, learning_rate=0.001\n", + "Epoch 106/144 - loss=0.7275818, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5217343, MSE_maskV_-1.0=0.72753549, val_loss=0.79088449, val_CC_maskV_-1.0=0.50027251, val_MSE_maskV_-1.0=0.78679448, learning_rate=0.001\n", + "Epoch 121/144 - loss=0.72534013, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52388239, MSE_maskV_-1.0=0.72587085, val_loss=0.78054428, val_CC_maskV_-1.0=0.50817353, val_MSE_maskV_-1.0=0.77659875, learning_rate=0.001\n", + "Epoch 136/144 - loss=0.72379142, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52573913, MSE_maskV_-1.0=0.72366315, val_loss=0.77562374, val_CC_maskV_-1.0=0.51132399, val_MSE_maskV_-1.0=0.77186638, learning_rate=0.001\n", + "Epoch 144/144 - loss=0.72199821, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52762955, MSE_maskV_-1.0=0.72164536, val_loss=0.77707607, val_CC_maskV_-1.0=0.51102602, val_MSE_maskV_-1.0=0.77289355, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:33:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 35.85s\n", + "\u001b[32m2025-05-30 12:33:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.77488279)\n", + "\u001b[32m2025-05-30 12:33:50\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 742us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:33:51\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.721, R2_maskV_-1.0=0.279, CC_maskV_-1.0=0.529\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 753us/step\n", + "51/51 [==============================] - 0s 739us/step\n", + "84/84 [==============================] - 0s 690us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:33:51\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_Cz1HL64U_ErSV16\" (4/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_Cz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:33:51\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_Cy1HL64U_ErSV16\" (5/16)\n", + "\u001b[32m2025-05-30 12:33:51\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_Cy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:33:51\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:33:51\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:33:51\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:33:51\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:33:51\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:33:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:34:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 219 (stopped at 234 epochs).\n", + "\u001b[32m2025-05-30 12:34:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/235 - loss=rnn_1step_loss=1.0047859, rnn_1step_R2_maskV_-1.0=-0.010058362, rnn_1step_CC_maskV_-1.0=0.036533557, rnn_1step_MSE_maskV_-1.0=1.004786, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0860175, val_rnn_1step_R2_maskV_-1.0=-0.039117754, val_rnn_1step_CC_maskV_-1.0=0.11707118, learning_rate=0.001\n", + "Epoch 25/235 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.5996663, rnn_1step_R2_maskV_-1.0=0.39328375, rnn_1step_CC_maskV_-1.0=0.6344012, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.70000505, val_rnn_1step_R2_maskV_-1.0=0.32783508, val_rnn_1step_CC_maskV_-1.0=0.59946102, learning_rate=0.001\n", + "Epoch 49/235 - loss=rnn_1step_loss=0.51820713, rnn_1step_R2_maskV_-1.0=0.47441536, rnn_1step_CC_maskV_-1.0=0.69562328, rnn_1step_MSE_maskV_-1.0=0.51820719, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59064049, val_rnn_1step_R2_maskV_-1.0=0.43591183, val_rnn_1step_CC_maskV_-1.0=0.67360204, learning_rate=0.001\n", + "Epoch 73/235 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.46693143, rnn_1step_R2_maskV_-1.0=0.52478701, rnn_1step_CC_maskV_-1.0=0.73143613, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.507617, val_rnn_1step_R2_maskV_-1.0=0.51556677, val_rnn_1step_CC_maskV_-1.0=0.72812688, learning_rate=0.001\n", + "Epoch 97/235 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.43439209, rnn_1step_R2_maskV_-1.0=0.5577181, rnn_1step_CC_maskV_-1.0=0.75338191, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48606753, val_rnn_1step_R2_maskV_-1.0=0.53550363, val_rnn_1step_CC_maskV_-1.0=0.74218917, learning_rate=0.001\n", + "Epoch 121/235 - loss=rnn_1step_loss=0.42659625, rnn_1step_R2_maskV_-1.0=0.56488311, rnn_1step_CC_maskV_-1.0=0.75845271, rnn_1step_MSE_maskV_-1.0=0.42659622, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47936645, val_rnn_1step_R2_maskV_-1.0=0.54173541, val_rnn_1step_CC_maskV_-1.0=0.74614042, learning_rate=0.001\n", + "Epoch 145/235 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42324185, rnn_1step_R2_maskV_-1.0=0.56790709, rnn_1step_CC_maskV_-1.0=0.76061511, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47654811, val_rnn_1step_R2_maskV_-1.0=0.54443276, val_rnn_1step_CC_maskV_-1.0=0.74779165, learning_rate=0.001\n", + "Epoch 169/235 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42128518, rnn_1step_R2_maskV_-1.0=0.56972563, rnn_1step_CC_maskV_-1.0=0.76187849, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47534433, val_rnn_1step_R2_maskV_-1.0=0.54557472, val_rnn_1step_CC_maskV_-1.0=0.74852169, learning_rate=0.001\n", + "Epoch 193/235 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41975236, rnn_1step_R2_maskV_-1.0=0.57119918, rnn_1step_CC_maskV_-1.0=0.76286507, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47483596, val_rnn_1step_R2_maskV_-1.0=0.54603279, val_rnn_1step_CC_maskV_-1.0=0.74884552, learning_rate=0.001\n", + "Epoch 217/235 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41842994, rnn_1step_R2_maskV_-1.0=0.57249117, rnn_1step_CC_maskV_-1.0=0.76371264, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4746801, val_rnn_1step_R2_maskV_-1.0=0.54614419, val_rnn_1step_CC_maskV_-1.0=0.74895155, learning_rate=0.001\n", + "Epoch 235/235 - loss=rnn_1step_loss=0.41755435, rnn_1step_R2_maskV_-1.0=0.57334769, rnn_1step_CC_maskV_-1.0=0.76427931, rnn_1step_MSE_maskV_-1.0=0.41755438, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47468114, val_rnn_1step_R2_maskV_-1.0=0.54611325, val_rnn_1step_CC_maskV_-1.0=0.74895525, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:34:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 21.78s\n", + "\u001b[32m2025-05-30 12:34:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:34:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 248 (stopped at 263 epochs).\n", + "\u001b[32m2025-05-30 12:34:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/264 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.998761, rnn_1_1step_R2_maskV_-1.0=-0.004015822, rnn_1_1step_CC_maskV_-1.0=0.14558986, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0801681, val_rnn_1_1step_R2_maskV_-1.0=-0.033871412, val_rnn_1_1step_CC_maskV_-1.0=0.19616058, learning_rate=0.001\n", + "Epoch 28/264 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.56824428, rnn_1_1step_R2_maskV_-1.0=0.42261872, rnn_1_1step_CC_maskV_-1.0=0.65847617, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6287536, val_rnn_1_1step_R2_maskV_-1.0=0.39648265, val_rnn_1_1step_CC_maskV_-1.0=0.64658809, learning_rate=0.001\n", + "Epoch 55/264 - loss=rnn_1_1step_loss=0.4894, rnn_1_1step_R2_maskV_-1.0=0.50229925, rnn_1_1step_CC_maskV_-1.0=0.71610683, rnn_1_1step_MSE_maskV_-1.0=0.48939997, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52397823, val_rnn_1_1step_R2_maskV_-1.0=0.49775711, val_rnn_1_1step_CC_maskV_-1.0=0.71918994, learning_rate=0.001\n", + "Epoch 82/264 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.45053032, rnn_1_1step_R2_maskV_-1.0=0.54169595, rnn_1_1step_CC_maskV_-1.0=0.74278855, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5102067, val_rnn_1_1step_R2_maskV_-1.0=0.5093984, val_rnn_1_1step_CC_maskV_-1.0=0.7282815, learning_rate=0.001\n", + "Epoch 109/264 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42900464, rnn_1_1step_R2_maskV_-1.0=0.56252325, rnn_1_1step_CC_maskV_-1.0=0.75693446, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49188244, val_rnn_1_1step_R2_maskV_-1.0=0.52864754, val_rnn_1_1step_CC_maskV_-1.0=0.73916852, learning_rate=0.001\n", + "Epoch 136/264 - loss=rnn_1_1step_loss=0.42239141, rnn_1_1step_R2_maskV_-1.0=0.56875426, rnn_1_1step_CC_maskV_-1.0=0.76119971, rnn_1_1step_MSE_maskV_-1.0=0.42239138, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4827095, val_rnn_1_1step_R2_maskV_-1.0=0.53797817, val_rnn_1_1step_CC_maskV_-1.0=0.74465674, learning_rate=0.001\n", + "Epoch 163/264 - loss=rnn_1_1step_loss=0.4184413, rnn_1_1step_R2_maskV_-1.0=0.57253259, rnn_1_1step_CC_maskV_-1.0=0.76372582, rnn_1_1step_MSE_maskV_-1.0=0.41844127, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47759843, val_rnn_1_1step_R2_maskV_-1.0=0.54308206, val_rnn_1_1step_CC_maskV_-1.0=0.74755681, learning_rate=0.001\n", + "Epoch 190/264 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41642645, rnn_1_1step_R2_maskV_-1.0=0.57446992, rnn_1_1step_CC_maskV_-1.0=0.76501739, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47511628, val_rnn_1_1step_R2_maskV_-1.0=0.54555291, val_rnn_1_1step_CC_maskV_-1.0=0.74889588, learning_rate=0.001\n", + "Epoch 217/264 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41509971, rnn_1_1step_R2_maskV_-1.0=0.57576454, rnn_1_1step_CC_maskV_-1.0=0.76587248, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47407928, val_rnn_1_1step_R2_maskV_-1.0=0.5465889, val_rnn_1_1step_CC_maskV_-1.0=0.7494204, learning_rate=0.001\n", + "Epoch 244/264 - loss=rnn_1_1step_loss=0.4140366, rnn_1_1step_R2_maskV_-1.0=0.57681668, rnn_1_1step_CC_maskV_-1.0=0.76655912, rnn_1_1step_MSE_maskV_-1.0=0.41403657, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47377118, val_rnn_1_1step_R2_maskV_-1.0=0.54690349, val_rnn_1_1step_CC_maskV_-1.0=0.74954647, learning_rate=0.001\n", + "Epoch 264/264 - loss=rnn_1_1step_loss=0.41333556, rnn_1_1step_R2_maskV_-1.0=0.57751673, rnn_1_1step_CC_maskV_-1.0=0.76701236, rnn_1_1step_MSE_maskV_-1.0=0.41333559, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47383165, val_rnn_1_1step_R2_maskV_-1.0=0.54685324, val_rnn_1_1step_CC_maskV_-1.0=0.74948376, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:34:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 23.94s\n", + "\u001b[32m2025-05-30 12:34:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.47376665)\n", + "\u001b[32m2025-05-30 12:34:39\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.358, R2_maskV_-1.0=0.642, CC_maskV_-1.0=0.801\n", + "\u001b[32m2025-05-30 12:34:39\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.46, R2_maskV_-1.0=0.549, CC_maskV_-1.0=0.753\n", + "\u001b[32m2025-05-30 12:34:39\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:34:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:35:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 76 (stopped at 91 epochs).\n", + "\u001b[32m2025-05-30 12:35:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/92 - loss=3.3198824, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.02792093, MSE_maskV_-1.0=3.3147187, val_loss=1.2883546, val_CC_maskV_-1.0=0.037511338, val_MSE_maskV_-1.0=1.2792974, learning_rate=0.001\n", + "Epoch 11/92 - loss=0.88666803, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.33833241, MSE_maskV_-1.0=0.88682961, val_loss=0.95784193, val_CC_maskV_-1.0=0.31053421, val_MSE_maskV_-1.0=0.95350581, learning_rate=0.001\n", + "Epoch 21/92 - loss=0.81424469, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43055165, MSE_maskV_-1.0=0.81420851, val_loss=0.88877803, val_CC_maskV_-1.0=0.39587432, val_MSE_maskV_-1.0=0.88568461, learning_rate=0.001\n", + "Epoch 31/92 - loss=0.7613464, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48864168, MSE_maskV_-1.0=0.76095438, val_loss=0.82073444, val_CC_maskV_-1.0=0.46695337, val_MSE_maskV_-1.0=0.81797266, learning_rate=0.001\n", + "Epoch 41/92 - loss=0.72654688, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52257895, MSE_maskV_-1.0=0.72630829, val_loss=0.79562742, val_CC_maskV_-1.0=0.49338704, val_MSE_maskV_-1.0=0.79259139, learning_rate=0.001\n", + "Epoch 51/92 - loss=0.7099008, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53842133, MSE_maskV_-1.0=0.71045792, val_loss=0.78444701, val_CC_maskV_-1.0=0.50268859, val_MSE_maskV_-1.0=0.78147656, learning_rate=0.001\n", + "Epoch 61/92 - loss=0.70134056, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54631478, MSE_maskV_-1.0=0.70139486, val_loss=0.77305037, val_CC_maskV_-1.0=0.51117146, val_MSE_maskV_-1.0=0.77024889, learning_rate=0.001\n", + "Epoch 71/92 - loss=0.69609541, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55013889, MSE_maskV_-1.0=0.69600248, val_loss=0.76575536, val_CC_maskV_-1.0=0.51731551, val_MSE_maskV_-1.0=0.76291978, learning_rate=0.001\n", + "Epoch 81/92 - loss=0.68865782, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55619192, MSE_maskV_-1.0=0.68891191, val_loss=0.75632602, val_CC_maskV_-1.0=0.52488154, val_MSE_maskV_-1.0=0.7534076, learning_rate=0.001\n", + "Epoch 91/92 - loss=0.68563521, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5595085, MSE_maskV_-1.0=0.68554437, val_loss=0.76015514, val_CC_maskV_-1.0=0.52380246, val_MSE_maskV_-1.0=0.75694853, learning_rate=0.001\n", + "Epoch 92/92 - loss=0.68660873, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55874223, MSE_maskV_-1.0=0.68734038, val_loss=0.75797772, val_CC_maskV_-1.0=0.52347237, val_MSE_maskV_-1.0=0.75518793, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:35:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 25.61s\n", + "\u001b[32m2025-05-30 12:35:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:35:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 166 (stopped at 181 epochs).\n", + "\u001b[32m2025-05-30 12:35:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/182 - loss=4.2782454, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.022146979, MSE_maskV_-1.0=4.2701411, val_loss=1.3708285, val_CC_maskV_-1.0=0.037260968, val_MSE_maskV_-1.0=1.3634931, learning_rate=0.001\n", + "Epoch 20/182 - loss=0.83069444, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41217813, MSE_maskV_-1.0=0.83068877, val_loss=0.91489053, val_CC_maskV_-1.0=0.36983863, val_MSE_maskV_-1.0=0.91065121, learning_rate=0.001\n", + "Epoch 39/182 - loss=0.74552917, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50478333, MSE_maskV_-1.0=0.74536335, val_loss=0.8109712, val_CC_maskV_-1.0=0.47795737, val_MSE_maskV_-1.0=0.80769211, learning_rate=0.001\n", + "Epoch 58/182 - loss=0.7123825, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53677851, MSE_maskV_-1.0=0.7121712, val_loss=0.7844547, val_CC_maskV_-1.0=0.50045198, val_MSE_maskV_-1.0=0.78161699, learning_rate=0.001\n", + "Epoch 77/182 - loss=0.69948667, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54800695, MSE_maskV_-1.0=0.69939953, val_loss=0.77226961, val_CC_maskV_-1.0=0.51319581, val_MSE_maskV_-1.0=0.7695111, learning_rate=0.001\n", + "Epoch 96/182 - loss=0.68937844, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55680078, MSE_maskV_-1.0=0.6893034, val_loss=0.76294678, val_CC_maskV_-1.0=0.51980233, val_MSE_maskV_-1.0=0.76015157, learning_rate=0.001\n", + "Epoch 115/182 - loss=0.68682164, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55822957, MSE_maskV_-1.0=0.68640828, val_loss=0.76435554, val_CC_maskV_-1.0=0.5213784, val_MSE_maskV_-1.0=0.76161426, learning_rate=0.001\n", + "Epoch 134/182 - loss=0.67952079, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56460625, MSE_maskV_-1.0=0.67958844, val_loss=0.75455284, val_CC_maskV_-1.0=0.52727592, val_MSE_maskV_-1.0=0.75183284, learning_rate=0.001\n", + "Epoch 153/182 - loss=0.67290062, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57067376, MSE_maskV_-1.0=0.67284137, val_loss=0.7629084, val_CC_maskV_-1.0=0.52176112, val_MSE_maskV_-1.0=0.75998867, learning_rate=0.001\n", + "Epoch 172/182 - loss=0.67024827, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57267922, MSE_maskV_-1.0=0.67018276, val_loss=0.7489022, val_CC_maskV_-1.0=0.53254443, val_MSE_maskV_-1.0=0.74625987, learning_rate=0.001\n", + "Epoch 182/182 - loss=0.66934884, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57279056, MSE_maskV_-1.0=0.67025012, val_loss=0.74349654, val_CC_maskV_-1.0=0.53486741, val_MSE_maskV_-1.0=0.74117988, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:35:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 48.26s\n", + "\u001b[32m2025-05-30 12:35:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.73911351)\n", + "\u001b[32m2025-05-30 12:35:53\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 794us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:35:53\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.66, R2_maskV_-1.0=0.342, CC_maskV_-1.0=0.584\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 785us/step\n", + "51/51 [==============================] - 0s 869us/step\n", + "84/84 [==============================] - 0s 768us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:35:54\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_Cy1HL64U_ErSV16\" (5/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_Cy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:35:54\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_uAK1HL64U_ErSV16\" (6/16)\n", + "\u001b[32m2025-05-30 12:35:54\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAK1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:35:54\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:35:54\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:35:54\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:35:54\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:35:54\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:35:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:36:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 97 (stopped at 112 epochs).\n", + "\u001b[32m2025-05-30 12:36:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/113 - loss=rnn_1step_loss=1.0050036, rnn_1step_R2_maskV_-1.0=-0.010395415, rnn_1step_CC_maskV_-1.0=0.11002284, rnn_1step_MSE_maskV_-1.0=1.0050037, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0887429, val_rnn_1step_R2_maskV_-1.0=-0.041721478, val_rnn_1step_CC_maskV_-1.0=0.22873712, learning_rate=0.001\n", + "Epoch 13/113 - loss=rnn_1step_loss=0.80212957, rnn_1step_R2_maskV_-1.0=0.18673797, rnn_1step_CC_maskV_-1.0=0.45425335, rnn_1step_MSE_maskV_-1.0=0.80212963, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.89597535, val_rnn_1step_R2_maskV_-1.0=0.14324588, val_rnn_1step_CC_maskV_-1.0=0.44029436, learning_rate=0.001\n", + "Epoch 25/113 - loss=rnn_1step_loss=0.54762226, rnn_1step_R2_maskV_-1.0=0.44287074, rnn_1step_CC_maskV_-1.0=0.67391002, rnn_1step_MSE_maskV_-1.0=0.54762232, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.66451591, val_rnn_1step_R2_maskV_-1.0=0.36037487, val_rnn_1step_CC_maskV_-1.0=0.62477738, learning_rate=0.001\n", + "Epoch 37/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42882529, rnn_1step_R2_maskV_-1.0=0.56186259, rnn_1step_CC_maskV_-1.0=0.75696635, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52988881, val_rnn_1step_R2_maskV_-1.0=0.49071059, val_rnn_1step_CC_maskV_-1.0=0.71464771, learning_rate=0.001\n", + "Epoch 49/113 - loss=rnn_1step_loss=0.37170586, rnn_1step_R2_maskV_-1.0=0.61931229, rnn_1step_CC_maskV_-1.0=0.79423642, rnn_1step_MSE_maskV_-1.0=0.37170583, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49268922, val_rnn_1step_R2_maskV_-1.0=0.52743816, val_rnn_1step_CC_maskV_-1.0=0.73609984, learning_rate=0.001\n", + "Epoch 61/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33179763, rnn_1step_R2_maskV_-1.0=0.66004795, rnn_1step_CC_maskV_-1.0=0.81867087, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47441244, val_rnn_1step_R2_maskV_-1.0=0.5443086, val_rnn_1step_CC_maskV_-1.0=0.74854952, learning_rate=0.001\n", + "Epoch 73/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29859948, rnn_1step_R2_maskV_-1.0=0.69400209, rnn_1step_CC_maskV_-1.0=0.83896774, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47244859, val_rnn_1step_R2_maskV_-1.0=0.54601914, val_rnn_1step_CC_maskV_-1.0=0.74990475, learning_rate=0.001\n", + "Epoch 85/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.26930904, rnn_1step_R2_maskV_-1.0=0.72432309, rnn_1step_CC_maskV_-1.0=0.85584593, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46866417, val_rnn_1step_R2_maskV_-1.0=0.54922169, val_rnn_1step_CC_maskV_-1.0=0.75326085, learning_rate=0.001\n", + "Epoch 97/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.25326574, rnn_1step_R2_maskV_-1.0=0.74061614, rnn_1step_CC_maskV_-1.0=0.86502308, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.43136168, val_rnn_1step_R2_maskV_-1.0=0.58587611, val_rnn_1step_CC_maskV_-1.0=0.77589136, learning_rate=0.001\n", + "Epoch 109/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.24292238, rnn_1step_R2_maskV_-1.0=0.75152469, rnn_1step_CC_maskV_-1.0=0.87100577, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45431122, val_rnn_1step_R2_maskV_-1.0=0.5630362, val_rnn_1step_CC_maskV_-1.0=0.76460069, learning_rate=0.001\n", + "Epoch 113/113 - loss=rnn_1step_loss=0.2350754, rnn_1step_R2_maskV_-1.0=0.75932223, rnn_1step_CC_maskV_-1.0=0.87589401, rnn_1step_MSE_maskV_-1.0=0.23507538, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4342351, val_rnn_1step_R2_maskV_-1.0=0.58309007, val_rnn_1step_CC_maskV_-1.0=0.77434868, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:36:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.02s\n", + "\u001b[32m2025-05-30 12:36:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:36:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 137 (stopped at 152 epochs).\n", + "\u001b[32m2025-05-30 12:36:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/153 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0051923, rnn_1_1step_R2_maskV_-1.0=-0.010616668, rnn_1_1step_CC_maskV_-1.0=0.092162907, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0887909, val_rnn_1_1step_R2_maskV_-1.0=-0.041738316, val_rnn_1_1step_CC_maskV_-1.0=0.28685841, learning_rate=0.001\n", + "Epoch 17/153 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.68051225, rnn_1_1step_R2_maskV_-1.0=0.30880037, rnn_1_1step_CC_maskV_-1.0=0.57064939, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.78360242, val_rnn_1_1step_R2_maskV_-1.0=0.2425998, val_rnn_1_1step_CC_maskV_-1.0=0.54294026, learning_rate=0.001\n", + "Epoch 33/153 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.5162977, rnn_1_1step_R2_maskV_-1.0=0.47330248, rnn_1_1step_CC_maskV_-1.0=0.69845462, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65933424, val_rnn_1_1step_R2_maskV_-1.0=0.36125916, val_rnn_1_1step_CC_maskV_-1.0=0.63106304, learning_rate=0.001\n", + "Epoch 49/153 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39215991, rnn_1_1step_R2_maskV_-1.0=0.59878105, rnn_1_1step_CC_maskV_-1.0=0.78057379, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56027347, val_rnn_1_1step_R2_maskV_-1.0=0.46050954, val_rnn_1_1step_CC_maskV_-1.0=0.69680011, learning_rate=0.001\n", + "Epoch 65/153 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.29686877, rnn_1_1step_R2_maskV_-1.0=0.69666755, rnn_1_1step_CC_maskV_-1.0=0.83949864, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50850183, val_rnn_1_1step_R2_maskV_-1.0=0.51018029, val_rnn_1_1step_CC_maskV_-1.0=0.73083693, learning_rate=0.001\n", + "Epoch 81/153 - loss=rnn_1_1step_loss=0.25480402, rnn_1_1step_R2_maskV_-1.0=0.73962522, rnn_1_1step_CC_maskV_-1.0=0.86439705, rnn_1_1step_MSE_maskV_-1.0=0.25480399, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51318765, val_rnn_1_1step_R2_maskV_-1.0=0.50505877, val_rnn_1_1step_CC_maskV_-1.0=0.73207176, learning_rate=0.001\n", + "Epoch 97/153 - loss=rnn_1_1step_loss=0.22861223, rnn_1_1step_R2_maskV_-1.0=0.76667887, rnn_1_1step_CC_maskV_-1.0=0.87939191, rnn_1_1step_MSE_maskV_-1.0=0.22861221, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49892411, val_rnn_1_1step_R2_maskV_-1.0=0.51965201, val_rnn_1_1step_CC_maskV_-1.0=0.7383101, learning_rate=0.001\n", + "Epoch 113/153 - loss=rnn_1_1step_loss=0.21365313, rnn_1_1step_R2_maskV_-1.0=0.78189063, rnn_1_1step_CC_maskV_-1.0=0.88768393, rnn_1_1step_MSE_maskV_-1.0=0.21365315, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49094284, val_rnn_1_1step_R2_maskV_-1.0=0.52753413, val_rnn_1_1step_CC_maskV_-1.0=0.74384224, learning_rate=0.001\n", + "Epoch 129/153 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.20342012, rnn_1_1step_R2_maskV_-1.0=0.79247391, rnn_1_1step_CC_maskV_-1.0=0.89347434, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45764831, val_rnn_1_1step_R2_maskV_-1.0=0.55954516, val_rnn_1_1step_CC_maskV_-1.0=0.76219183, learning_rate=0.001\n", + "Epoch 145/153 - loss=rnn_1_1step_loss=0.19592339, rnn_1_1step_R2_maskV_-1.0=0.79995704, rnn_1_1step_CC_maskV_-1.0=0.89739114, rnn_1_1step_MSE_maskV_-1.0=0.19592337, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46692634, val_rnn_1_1step_R2_maskV_-1.0=0.55095124, val_rnn_1_1step_CC_maskV_-1.0=0.75624204, learning_rate=0.001\n", + "Epoch 153/153 - loss=rnn_1_1step_loss=0.19690263, rnn_1_1step_R2_maskV_-1.0=0.79911852, rnn_1_1step_CC_maskV_-1.0=0.89725679, rnn_1_1step_MSE_maskV_-1.0=0.19690265, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48004842, val_rnn_1_1step_R2_maskV_-1.0=0.53711301, val_rnn_1_1step_CC_maskV_-1.0=0.75093144, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:36:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 18.79s\n", + "\u001b[32m2025-05-30 12:36:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.43136168)\n", + "\u001b[32m2025-05-30 12:36:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.228, R2_maskV_-1.0=0.772, CC_maskV_-1.0=0.879\n", + "\u001b[32m2025-05-30 12:36:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.407, R2_maskV_-1.0=0.601, CC_maskV_-1.0=0.785\n", + "\u001b[32m2025-05-30 12:36:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:36:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:38:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 405 (stopped at 420 epochs).\n", + "\u001b[32m2025-05-30 12:38:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/421 - loss=1.5750186, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.032890193, MSE_maskV_-1.0=1.5748197, val_loss=1.1335682, val_CC_maskV_-1.0=0.080398336, val_MSE_maskV_-1.0=1.1259886, learning_rate=0.001\n", + "Epoch 44/421 - loss=0.90267044, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.31684595, MSE_maskV_-1.0=0.90235215, val_loss=0.97300482, val_CC_maskV_-1.0=0.28823453, val_MSE_maskV_-1.0=0.96745241, learning_rate=0.001\n", + "Epoch 87/421 - loss=0.88307589, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34679744, MSE_maskV_-1.0=0.88290095, val_loss=0.95416152, val_CC_maskV_-1.0=0.31685436, val_MSE_maskV_-1.0=0.94899511, learning_rate=0.001\n", + "Epoch 130/421 - loss=0.87260771, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36069077, MSE_maskV_-1.0=0.87271351, val_loss=0.93966722, val_CC_maskV_-1.0=0.33454818, val_MSE_maskV_-1.0=0.93458325, learning_rate=0.001\n", + "Epoch 173/421 - loss=0.86576951, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36899763, MSE_maskV_-1.0=0.86516726, val_loss=0.93120641, val_CC_maskV_-1.0=0.34394732, val_MSE_maskV_-1.0=0.92630422, learning_rate=0.001\n", + "Epoch 216/421 - loss=0.86023653, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37735775, MSE_maskV_-1.0=0.85978872, val_loss=0.92684036, val_CC_maskV_-1.0=0.34883532, val_MSE_maskV_-1.0=0.92191362, learning_rate=0.001\n", + "Epoch 259/421 - loss=0.85668623, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38115555, MSE_maskV_-1.0=0.85641479, val_loss=0.91999125, val_CC_maskV_-1.0=0.35778183, val_MSE_maskV_-1.0=0.91514921, learning_rate=0.001\n", + "Epoch 302/421 - loss=0.8537184, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38411519, MSE_maskV_-1.0=0.85362989, val_loss=0.91733009, val_CC_maskV_-1.0=0.35901123, val_MSE_maskV_-1.0=0.91246361, learning_rate=0.001\n", + "Epoch 345/421 - loss=0.85130137, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38680944, MSE_maskV_-1.0=0.85120618, val_loss=0.91522431, val_CC_maskV_-1.0=0.36185655, val_MSE_maskV_-1.0=0.91011274, learning_rate=0.001\n", + "Epoch 388/421 - loss=0.84931469, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.388926, MSE_maskV_-1.0=0.84908676, val_loss=0.91515094, val_CC_maskV_-1.0=0.36185691, val_MSE_maskV_-1.0=0.91037416, learning_rate=0.001\n", + "Epoch 421/421 - loss=0.84770781, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3910282, MSE_maskV_-1.0=0.84735227, val_loss=0.91067415, val_CC_maskV_-1.0=0.36492819, val_MSE_maskV_-1.0=0.90595752, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:38:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 103.15s\n", + "\u001b[32m2025-05-30 12:38:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:39:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 405 (stopped at 420 epochs).\n", + "\u001b[32m2025-05-30 12:39:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/421 - loss=1.7410058, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.012839095, MSE_maskV_-1.0=1.7403858, val_loss=1.1466686, val_CC_maskV_-1.0=0.057923011, val_MSE_maskV_-1.0=1.1389083, learning_rate=0.001\n", + "Epoch 44/421 - loss=0.90421706, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3144764, MSE_maskV_-1.0=0.90388328, val_loss=0.97458851, val_CC_maskV_-1.0=0.28639129, val_MSE_maskV_-1.0=0.96910805, learning_rate=0.001\n", + "Epoch 87/421 - loss=0.8835963, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34623191, MSE_maskV_-1.0=0.8834185, val_loss=0.95476151, val_CC_maskV_-1.0=0.31672576, val_MSE_maskV_-1.0=0.9496727, learning_rate=0.001\n", + "Epoch 130/421 - loss=0.87276894, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36068758, MSE_maskV_-1.0=0.87286657, val_loss=0.93997437, val_CC_maskV_-1.0=0.33448261, val_MSE_maskV_-1.0=0.93496686, learning_rate=0.001\n", + "Epoch 173/421 - loss=0.86581624, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36904699, MSE_maskV_-1.0=0.86521769, val_loss=0.93132383, val_CC_maskV_-1.0=0.34395206, val_MSE_maskV_-1.0=0.92648894, learning_rate=0.001\n", + "Epoch 216/421 - loss=0.86023778, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37741315, MSE_maskV_-1.0=0.85979056, val_loss=0.92688864, val_CC_maskV_-1.0=0.34893519, val_MSE_maskV_-1.0=0.92200905, learning_rate=0.001\n", + "Epoch 259/421 - loss=0.85667592, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38120201, MSE_maskV_-1.0=0.85640591, val_loss=0.92012912, val_CC_maskV_-1.0=0.35764632, val_MSE_maskV_-1.0=0.91533297, learning_rate=0.001\n", + "Epoch 302/421 - loss=0.85369796, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3841508, MSE_maskV_-1.0=0.85362023, val_loss=0.91744643, val_CC_maskV_-1.0=0.35887456, val_MSE_maskV_-1.0=0.91261357, learning_rate=0.001\n", + "Epoch 345/421 - loss=0.8512767, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38688663, MSE_maskV_-1.0=0.85117102, val_loss=0.91527003, val_CC_maskV_-1.0=0.36181343, val_MSE_maskV_-1.0=0.91019142, learning_rate=0.001\n", + "Epoch 388/421 - loss=0.84929174, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38896689, MSE_maskV_-1.0=0.84906757, val_loss=0.91530073, val_CC_maskV_-1.0=0.36167428, val_MSE_maskV_-1.0=0.91054732, learning_rate=0.001\n", + "Epoch 421/421 - loss=0.84768862, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39108342, MSE_maskV_-1.0=0.84732491, val_loss=0.9108395, val_CC_maskV_-1.0=0.36473742, val_MSE_maskV_-1.0=0.9061414, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:39:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 102.34s\n", + "\u001b[32m2025-05-30 12:39:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.91037548)\n", + "\u001b[32m2025-05-30 12:39:54\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 715us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:39:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.847, R2_maskV_-1.0=0.154, CC_maskV_-1.0=0.393\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 857us/step\n", + "51/51 [==============================] - 0s 785us/step\n", + "84/84 [==============================] - 0s 708us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:39:55\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_uAK1HL64U_ErSV16\" (6/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_uAK1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:39:55\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_ACz1HL64U_ErSV16\" (7/16)\n", + "\u001b[32m2025-05-30 12:39:55\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:39:55\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:39:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:39:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:39:56\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:39:56\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:39:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:40:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 203 (stopped at 218 epochs).\n", + "\u001b[32m2025-05-30 12:40:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/219 - loss=rnn_1step_loss=1.0054302, rnn_1step_R2_maskV_-1.0=-0.010819498, rnn_1step_CC_maskV_-1.0=0.079282679, rnn_1step_MSE_maskV_-1.0=1.0054301, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0893097, val_rnn_1step_R2_maskV_-1.0=-0.042296499, val_rnn_1step_CC_maskV_-1.0=0.2752704, learning_rate=0.001\n", + "Epoch 23/219 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.58754319, rnn_1step_R2_maskV_-1.0=0.40363535, rnn_1step_CC_maskV_-1.0=0.6447646, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.69574904, val_rnn_1step_R2_maskV_-1.0=0.32736993, val_rnn_1step_CC_maskV_-1.0=0.6051327, learning_rate=0.001\n", + "Epoch 45/219 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.48043385, rnn_1step_R2_maskV_-1.0=0.50992149, rnn_1step_CC_maskV_-1.0=0.72203755, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60953885, val_rnn_1step_R2_maskV_-1.0=0.41434333, val_rnn_1step_CC_maskV_-1.0=0.6633954, learning_rate=0.001\n", + "Epoch 67/219 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42345896, rnn_1step_R2_maskV_-1.0=0.56657809, rnn_1step_CC_maskV_-1.0=0.76039356, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54433244, val_rnn_1step_R2_maskV_-1.0=0.4787412, val_rnn_1step_CC_maskV_-1.0=0.70558327, learning_rate=0.001\n", + "Epoch 89/219 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38296628, rnn_1step_R2_maskV_-1.0=0.60712445, rnn_1step_CC_maskV_-1.0=0.78652227, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50264597, val_rnn_1step_R2_maskV_-1.0=0.51735622, val_rnn_1step_CC_maskV_-1.0=0.73397392, learning_rate=0.001\n", + "Epoch 111/219 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35627928, rnn_1step_R2_maskV_-1.0=0.63422322, rnn_1step_CC_maskV_-1.0=0.80370617, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47890997, val_rnn_1step_R2_maskV_-1.0=0.5403471, val_rnn_1step_CC_maskV_-1.0=0.74802363, learning_rate=0.001\n", + "Epoch 133/219 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3331432, rnn_1step_R2_maskV_-1.0=0.65727413, rnn_1step_CC_maskV_-1.0=0.81800187, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4734017, val_rnn_1step_R2_maskV_-1.0=0.54544842, val_rnn_1step_CC_maskV_-1.0=0.7505945, learning_rate=0.001\n", + "Epoch 155/219 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32548198, rnn_1step_R2_maskV_-1.0=0.6645335, rnn_1step_CC_maskV_-1.0=0.82263315, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46178868, val_rnn_1step_R2_maskV_-1.0=0.5577026, val_rnn_1step_CC_maskV_-1.0=0.75729388, learning_rate=0.001\n", + "Epoch 177/219 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31069455, rnn_1step_R2_maskV_-1.0=0.68057913, rnn_1step_CC_maskV_-1.0=0.83140856, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44165063, val_rnn_1step_R2_maskV_-1.0=0.5767411, val_rnn_1step_CC_maskV_-1.0=0.77041161, learning_rate=0.001\n", + "Epoch 199/219 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32133698, rnn_1step_R2_maskV_-1.0=0.67003012, rnn_1step_CC_maskV_-1.0=0.82539678, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48014882, val_rnn_1step_R2_maskV_-1.0=0.53853786, val_rnn_1step_CC_maskV_-1.0=0.74699575, learning_rate=0.001\n", + "Epoch 219/219 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3007431, rnn_1step_R2_maskV_-1.0=0.69090056, rnn_1step_CC_maskV_-1.0=0.83817261, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44587326, val_rnn_1step_R2_maskV_-1.0=0.57201862, val_rnn_1step_CC_maskV_-1.0=0.7653116, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:40:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 25.05s\n", + "\u001b[32m2025-05-30 12:40:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:40:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 243 (stopped at 258 epochs).\n", + "\u001b[32m2025-05-30 12:40:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/259 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0052651, rnn_1_1step_R2_maskV_-1.0=-0.010626208, rnn_1_1step_CC_maskV_-1.0=0.084891766, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0883164, val_rnn_1_1step_R2_maskV_-1.0=-0.041268736, val_rnn_1_1step_CC_maskV_-1.0=0.2722033, learning_rate=0.001\n", + "Epoch 27/259 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.55767781, rnn_1_1step_R2_maskV_-1.0=0.43329322, rnn_1_1step_CC_maskV_-1.0=0.66711783, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.67041975, val_rnn_1_1step_R2_maskV_-1.0=0.35669044, val_rnn_1_1step_CC_maskV_-1.0=0.62001079, learning_rate=0.001\n", + "Epoch 53/259 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44221187, rnn_1_1step_R2_maskV_-1.0=0.54762745, rnn_1_1step_CC_maskV_-1.0=0.74846476, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53630525, val_rnn_1_1step_R2_maskV_-1.0=0.48641467, val_rnn_1_1step_CC_maskV_-1.0=0.71016586, learning_rate=0.001\n", + "Epoch 79/259 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39178601, rnn_1_1step_R2_maskV_-1.0=0.59865153, rnn_1_1step_CC_maskV_-1.0=0.78183842, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47788391, val_rnn_1_1step_R2_maskV_-1.0=0.54266691, val_rnn_1_1step_CC_maskV_-1.0=0.74627876, learning_rate=0.001\n", + "Epoch 105/259 - loss=rnn_1_1step_loss=0.36754671, rnn_1_1step_R2_maskV_-1.0=0.62366045, rnn_1_1step_CC_maskV_-1.0=0.79693252, rnn_1_1step_MSE_maskV_-1.0=0.36754674, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47232404, val_rnn_1_1step_R2_maskV_-1.0=0.54778773, val_rnn_1_1step_CC_maskV_-1.0=0.74958056, learning_rate=0.001\n", + "Epoch 131/259 - loss=rnn_1_1step_loss=0.35158563, rnn_1_1step_R2_maskV_-1.0=0.64003927, rnn_1_1step_CC_maskV_-1.0=0.80716801, rnn_1_1step_MSE_maskV_-1.0=0.3515856, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45726085, val_rnn_1_1step_R2_maskV_-1.0=0.5621016, val_rnn_1_1step_CC_maskV_-1.0=0.75885582, learning_rate=0.001\n", + "Epoch 157/259 - loss=rnn_1_1step_loss=0.33865151, rnn_1_1step_R2_maskV_-1.0=0.65331006, rnn_1_1step_CC_maskV_-1.0=0.81523639, rnn_1_1step_MSE_maskV_-1.0=0.33865154, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.44862175, val_rnn_1_1step_R2_maskV_-1.0=0.57102132, val_rnn_1_1step_CC_maskV_-1.0=0.77115393, learning_rate=0.001\n", + "Epoch 183/259 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32262415, rnn_1_1step_R2_maskV_-1.0=0.66938913, rnn_1_1step_CC_maskV_-1.0=0.82519323, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.42811415, val_rnn_1_1step_R2_maskV_-1.0=0.589894, val_rnn_1_1step_CC_maskV_-1.0=0.77686536, learning_rate=0.001\n", + "Epoch 209/259 - loss=rnn_1_1step_loss=0.3134276, rnn_1_1step_R2_maskV_-1.0=0.67941749, rnn_1_1step_CC_maskV_-1.0=0.82985407, rnn_1_1step_MSE_maskV_-1.0=0.31342763, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41257855, val_rnn_1_1step_R2_maskV_-1.0=0.6047892, val_rnn_1_1step_CC_maskV_-1.0=0.78872716, learning_rate=0.001\n", + "Epoch 235/259 - loss=rnn_1_1step_loss=0.30730525, rnn_1_1step_R2_maskV_-1.0=0.68623048, rnn_1_1step_CC_maskV_-1.0=0.83422172, rnn_1_1step_MSE_maskV_-1.0=0.30730528, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41087571, val_rnn_1_1step_R2_maskV_-1.0=0.60630345, val_rnn_1_1step_CC_maskV_-1.0=0.79336756, learning_rate=0.001\n", + "Epoch 259/259 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31295523, rnn_1_1step_R2_maskV_-1.0=0.67933154, rnn_1_1step_CC_maskV_-1.0=0.83307797, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.42169785, val_rnn_1_1step_R2_maskV_-1.0=0.59455848, val_rnn_1_1step_CC_maskV_-1.0=0.78034484, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:40:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 29.43s\n", + "\u001b[32m2025-05-30 12:40:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.3988947)\n", + "\u001b[32m2025-05-30 12:40:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.266, R2_maskV_-1.0=0.734, CC_maskV_-1.0=0.857\n", + "\u001b[32m2025-05-30 12:40:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.386, R2_maskV_-1.0=0.622, CC_maskV_-1.0=0.799\n", + "\u001b[32m2025-05-30 12:40:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:40:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:41:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 151 (stopped at 166 epochs).\n", + "\u001b[32m2025-05-30 12:41:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/167 - loss=5.4002976, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0040973313, MSE_maskV_-1.0=5.3897796, val_loss=1.6601144, val_CC_maskV_-1.0=0.016424278, val_MSE_maskV_-1.0=1.6461452, learning_rate=0.001\n", + "Epoch 18/167 - loss=0.79050952, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45776811, MSE_maskV_-1.0=0.79043245, val_loss=0.85601741, val_CC_maskV_-1.0=0.43211788, val_MSE_maskV_-1.0=0.85275698, learning_rate=0.001\n", + "Epoch 35/167 - loss=0.74946326, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50102353, MSE_maskV_-1.0=0.74935341, val_loss=0.81710851, val_CC_maskV_-1.0=0.47167179, val_MSE_maskV_-1.0=0.81416255, learning_rate=0.001\n", + "Epoch 52/167 - loss=0.73527288, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51459676, MSE_maskV_-1.0=0.73509985, val_loss=0.79912102, val_CC_maskV_-1.0=0.48700204, val_MSE_maskV_-1.0=0.79667789, learning_rate=0.001\n", + "Epoch 69/167 - loss=0.72955561, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51995802, MSE_maskV_-1.0=0.72944731, val_loss=0.7918691, val_CC_maskV_-1.0=0.49291939, val_MSE_maskV_-1.0=0.78948927, learning_rate=0.001\n", + "Epoch 86/167 - loss=0.72593319, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52348524, MSE_maskV_-1.0=0.72625834, val_loss=0.78694588, val_CC_maskV_-1.0=0.49779305, val_MSE_maskV_-1.0=0.78476804, learning_rate=0.001\n", + "Epoch 103/167 - loss=0.72317421, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52614439, MSE_maskV_-1.0=0.72309881, val_loss=0.78652579, val_CC_maskV_-1.0=0.49745056, val_MSE_maskV_-1.0=0.78458822, learning_rate=0.001\n", + "Epoch 120/167 - loss=0.72103149, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52809191, MSE_maskV_-1.0=0.72073948, val_loss=0.78199458, val_CC_maskV_-1.0=0.50176042, val_MSE_maskV_-1.0=0.77953416, learning_rate=0.001\n", + "Epoch 137/167 - loss=0.72010756, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52803099, MSE_maskV_-1.0=0.7193256, val_loss=0.78206342, val_CC_maskV_-1.0=0.50148958, val_MSE_maskV_-1.0=0.77973795, learning_rate=0.001\n", + "Epoch 154/167 - loss=0.71965551, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52873784, MSE_maskV_-1.0=0.71932048, val_loss=0.77858371, val_CC_maskV_-1.0=0.50459564, val_MSE_maskV_-1.0=0.77634633, learning_rate=0.001\n", + "Epoch 167/167 - loss=0.71887535, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5298031, MSE_maskV_-1.0=0.71856821, val_loss=0.77888411, val_CC_maskV_-1.0=0.50396264, val_MSE_maskV_-1.0=0.776595, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:41:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 40.64s\n", + "\u001b[32m2025-05-30 12:41:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:42:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 151 (stopped at 166 epochs).\n", + "\u001b[32m2025-05-30 12:42:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/167 - loss=6.1198936, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.031900067, MSE_maskV_-1.0=6.1074662, val_loss=1.7197816, val_CC_maskV_-1.0=0.055529762, val_MSE_maskV_-1.0=1.7033467, learning_rate=0.001\n", + "Epoch 18/167 - loss=0.79068947, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45772889, MSE_maskV_-1.0=0.79069078, val_loss=0.85799265, val_CC_maskV_-1.0=0.42918304, val_MSE_maskV_-1.0=0.85490918, learning_rate=0.001\n", + "Epoch 35/167 - loss=0.74979228, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50077909, MSE_maskV_-1.0=0.74970597, val_loss=0.81810641, val_CC_maskV_-1.0=0.4703691, val_MSE_maskV_-1.0=0.81540352, learning_rate=0.001\n", + "Epoch 52/167 - loss=0.73525614, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51463908, MSE_maskV_-1.0=0.73506552, val_loss=0.79951262, val_CC_maskV_-1.0=0.4869065, val_MSE_maskV_-1.0=0.79726166, learning_rate=0.001\n", + "Epoch 69/167 - loss=0.72935641, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52011126, MSE_maskV_-1.0=0.72927022, val_loss=0.79237318, val_CC_maskV_-1.0=0.49274576, val_MSE_maskV_-1.0=0.79012954, learning_rate=0.001\n", + "Epoch 86/167 - loss=0.72567225, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52375424, MSE_maskV_-1.0=0.72601062, val_loss=0.78703207, val_CC_maskV_-1.0=0.49804214, val_MSE_maskV_-1.0=0.78496993, learning_rate=0.001\n", + "Epoch 103/167 - loss=0.7229017, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52646136, MSE_maskV_-1.0=0.72283483, val_loss=0.78631479, val_CC_maskV_-1.0=0.49798179, val_MSE_maskV_-1.0=0.78447276, learning_rate=0.001\n", + "Epoch 120/167 - loss=0.7208373, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52831352, MSE_maskV_-1.0=0.7205444, val_loss=0.78150642, val_CC_maskV_-1.0=0.50239724, val_MSE_maskV_-1.0=0.77912629, learning_rate=0.001\n", + "Epoch 137/167 - loss=0.71994966, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52822095, MSE_maskV_-1.0=0.71916068, val_loss=0.78164625, val_CC_maskV_-1.0=0.50200868, val_MSE_maskV_-1.0=0.77940929, learning_rate=0.001\n", + "Epoch 154/167 - loss=0.71952182, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52886957, MSE_maskV_-1.0=0.71918166, val_loss=0.77831334, val_CC_maskV_-1.0=0.50494552, val_MSE_maskV_-1.0=0.77613622, learning_rate=0.001\n", + "Epoch 167/167 - loss=0.71877557, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52991259, MSE_maskV_-1.0=0.71846116, val_loss=0.77851748, val_CC_maskV_-1.0=0.50435621, val_MSE_maskV_-1.0=0.77629328, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:42:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 41.14s\n", + "\u001b[32m2025-05-30 12:42:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.77748758)\n", + "\u001b[32m2025-05-30 12:42:14\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 749us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:42:14\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.717, R2_maskV_-1.0=0.282, CC_maskV_-1.0=0.532\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 765us/step\n", + "51/51 [==============================] - 0s 735us/step\n", + "84/84 [==============================] - 0s 686us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:42:15\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_ACz1HL64U_ErSV16\" (7/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_ACz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:42:15\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_ACy1HL64U_ErSV16\" (8/16)\n", + "\u001b[32m2025-05-30 12:42:15\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:42:15\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:42:15\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:42:15\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:42:15\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:42:15\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:42:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:42:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 134 (stopped at 149 epochs).\n", + "\u001b[32m2025-05-30 12:42:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/150 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0057583, rnn_1step_R2_maskV_-1.0=-0.011275027, rnn_1step_CC_maskV_-1.0=0.018942364, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0855269, val_rnn_1step_R2_maskV_-1.0=-0.038400963, val_rnn_1step_CC_maskV_-1.0=0.13493095, learning_rate=0.001\n", + "Epoch 16/150 - loss=rnn_1step_loss=0.74250221, rnn_1step_R2_maskV_-1.0=0.24746242, rnn_1step_CC_maskV_-1.0=0.51335794, rnn_1step_MSE_maskV_-1.0=0.74250227, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.84340769, val_rnn_1step_R2_maskV_-1.0=0.19426511, val_rnn_1step_CC_maskV_-1.0=0.48605961, learning_rate=0.001\n", + "Epoch 31/150 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.5510183, rnn_1step_R2_maskV_-1.0=0.43987054, rnn_1step_CC_maskV_-1.0=0.67120129, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.67137402, val_rnn_1step_R2_maskV_-1.0=0.35536212, val_rnn_1step_CC_maskV_-1.0=0.61880386, learning_rate=0.001\n", + "Epoch 46/150 - loss=rnn_1step_loss=0.48511997, rnn_1step_R2_maskV_-1.0=0.50437284, rnn_1step_CC_maskV_-1.0=0.71855617, rnn_1step_MSE_maskV_-1.0=0.48512, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.602907, val_rnn_1step_R2_maskV_-1.0=0.42325103, val_rnn_1step_CC_maskV_-1.0=0.66619354, learning_rate=0.001\n", + "Epoch 61/150 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.43593112, rnn_1step_R2_maskV_-1.0=0.55365992, rnn_1step_CC_maskV_-1.0=0.75184214, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55827457, val_rnn_1step_R2_maskV_-1.0=0.46571049, val_rnn_1step_CC_maskV_-1.0=0.69511986, learning_rate=0.001\n", + "Epoch 76/150 - loss=rnn_1step_loss=0.39834642, rnn_1step_R2_maskV_-1.0=0.59208393, rnn_1step_CC_maskV_-1.0=0.77628815, rnn_1step_MSE_maskV_-1.0=0.39834645, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54367125, val_rnn_1step_R2_maskV_-1.0=0.47971162, val_rnn_1step_CC_maskV_-1.0=0.70522422, learning_rate=0.001\n", + "Epoch 91/150 - loss=rnn_1step_loss=0.36944392, rnn_1step_R2_maskV_-1.0=0.62131417, rnn_1step_CC_maskV_-1.0=0.7952075, rnn_1step_MSE_maskV_-1.0=0.36944395, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51834655, val_rnn_1step_R2_maskV_-1.0=0.50299692, val_rnn_1step_CC_maskV_-1.0=0.7216422, learning_rate=0.001\n", + "Epoch 106/150 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3510603, rnn_1step_R2_maskV_-1.0=0.64031005, rnn_1step_CC_maskV_-1.0=0.8070007, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51419836, val_rnn_1step_R2_maskV_-1.0=0.50696319, val_rnn_1step_CC_maskV_-1.0=0.73059583, learning_rate=0.001\n", + "Epoch 121/150 - loss=rnn_1step_loss=0.34620246, rnn_1step_R2_maskV_-1.0=0.64519405, rnn_1step_CC_maskV_-1.0=0.81136942, rnn_1step_MSE_maskV_-1.0=0.34620243, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48966584, val_rnn_1step_R2_maskV_-1.0=0.52909338, val_rnn_1step_CC_maskV_-1.0=0.73862886, learning_rate=0.001\n", + "Epoch 136/150 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32338136, rnn_1step_R2_maskV_-1.0=0.66893858, rnn_1step_CC_maskV_-1.0=0.82366532, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48828816, val_rnn_1step_R2_maskV_-1.0=0.53045237, val_rnn_1step_CC_maskV_-1.0=0.74540305, learning_rate=0.001\n", + "Epoch 150/150 - loss=rnn_1step_loss=0.31461978, rnn_1step_R2_maskV_-1.0=0.67812908, rnn_1step_CC_maskV_-1.0=0.82920694, rnn_1step_MSE_maskV_-1.0=0.31461975, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48287407, val_rnn_1step_R2_maskV_-1.0=0.53535897, val_rnn_1step_CC_maskV_-1.0=0.74817002, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:42:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 18.44s\n", + "\u001b[32m2025-05-30 12:42:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:42:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 189 (stopped at 204 epochs).\n", + "\u001b[32m2025-05-30 12:42:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/205 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0035915, rnn_1_1step_R2_maskV_-1.0=-0.0090177059, rnn_1_1step_CC_maskV_-1.0=0.065030195, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0846311, val_rnn_1_1step_R2_maskV_-1.0=-0.037573889, val_rnn_1_1step_CC_maskV_-1.0=0.15325123, learning_rate=0.001\n", + "Epoch 22/205 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.62461543, rnn_1_1step_R2_maskV_-1.0=0.36701244, rnn_1_1step_CC_maskV_-1.0=0.61695087, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.7425521, val_rnn_1_1step_R2_maskV_-1.0=0.28569561, val_rnn_1_1step_CC_maskV_-1.0=0.57668847, learning_rate=0.001\n", + "Epoch 43/205 - loss=rnn_1_1step_loss=0.51181275, rnn_1_1step_R2_maskV_-1.0=0.47842422, rnn_1_1step_CC_maskV_-1.0=0.6999585, rnn_1_1step_MSE_maskV_-1.0=0.51181281, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63528466, val_rnn_1_1step_R2_maskV_-1.0=0.39033043, val_rnn_1_1step_CC_maskV_-1.0=0.64576149, learning_rate=0.001\n", + "Epoch 64/205 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44692311, rnn_1_1step_R2_maskV_-1.0=0.54291016, rnn_1_1step_CC_maskV_-1.0=0.74521762, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57522774, val_rnn_1_1step_R2_maskV_-1.0=0.44960129, val_rnn_1_1step_CC_maskV_-1.0=0.68742627, learning_rate=0.001\n", + "Epoch 85/205 - loss=rnn_1_1step_loss=0.38671955, rnn_1_1step_R2_maskV_-1.0=0.60412955, rnn_1_1step_CC_maskV_-1.0=0.78484178, rnn_1_1step_MSE_maskV_-1.0=0.38671952, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52662808, val_rnn_1_1step_R2_maskV_-1.0=0.49560145, val_rnn_1_1step_CC_maskV_-1.0=0.72096211, learning_rate=0.001\n", + "Epoch 106/205 - loss=rnn_1_1step_loss=0.37131023, rnn_1_1step_R2_maskV_-1.0=0.61974037, rnn_1_1step_CC_maskV_-1.0=0.79697084, rnn_1_1step_MSE_maskV_-1.0=0.37131026, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51100618, val_rnn_1_1step_R2_maskV_-1.0=0.51019502, val_rnn_1_1step_CC_maskV_-1.0=0.72479844, learning_rate=0.001\n", + "Epoch 127/205 - loss=rnn_1_1step_loss=0.34078911, rnn_1_1step_R2_maskV_-1.0=0.65063578, rnn_1_1step_CC_maskV_-1.0=0.81373715, rnn_1_1step_MSE_maskV_-1.0=0.34078914, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50639313, val_rnn_1_1step_R2_maskV_-1.0=0.51260376, val_rnn_1_1step_CC_maskV_-1.0=0.73562598, learning_rate=0.001\n", + "Epoch 148/205 - loss=rnn_1_1step_loss=0.32640854, rnn_1_1step_R2_maskV_-1.0=0.66514468, rnn_1_1step_CC_maskV_-1.0=0.82251978, rnn_1_1step_MSE_maskV_-1.0=0.32640857, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48144802, val_rnn_1_1step_R2_maskV_-1.0=0.53860134, val_rnn_1_1step_CC_maskV_-1.0=0.75135499, learning_rate=0.001\n", + "Epoch 169/205 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31231591, rnn_1_1step_R2_maskV_-1.0=0.67946666, rnn_1_1step_CC_maskV_-1.0=0.83065957, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47217488, val_rnn_1_1step_R2_maskV_-1.0=0.54823685, val_rnn_1_1step_CC_maskV_-1.0=0.75868982, learning_rate=0.001\n", + "Epoch 190/205 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30314997, rnn_1_1step_R2_maskV_-1.0=0.68890715, rnn_1_1step_CC_maskV_-1.0=0.83666766, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4795295, val_rnn_1_1step_R2_maskV_-1.0=0.54246753, val_rnn_1_1step_CC_maskV_-1.0=0.75751042, learning_rate=0.001\n", + "Epoch 205/205 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30243039, rnn_1_1step_R2_maskV_-1.0=0.68960077, rnn_1_1step_CC_maskV_-1.0=0.837156, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45646572, val_rnn_1_1step_R2_maskV_-1.0=0.56413335, val_rnn_1_1step_CC_maskV_-1.0=0.76615316, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:42:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 23.53s\n", + "\u001b[32m2025-05-30 12:42:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.45397165)\n", + "\u001b[32m2025-05-30 12:42:59\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.269, R2_maskV_-1.0=0.731, CC_maskV_-1.0=0.855\n", + "\u001b[32m2025-05-30 12:42:59\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.416, R2_maskV_-1.0=0.595, CC_maskV_-1.0=0.781\n", + "\u001b[32m2025-05-30 12:42:59\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:42:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:44:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 227 (stopped at 242 epochs).\n", + "\u001b[32m2025-05-30 12:44:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/243 - loss=1.4044077, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.10565028, MSE_maskV_-1.0=1.4042914, val_loss=1.0552539, val_CC_maskV_-1.0=0.18211885, val_MSE_maskV_-1.0=1.0488069, learning_rate=0.001\n", + "Epoch 26/243 - loss=0.6931861, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55270463, MSE_maskV_-1.0=0.69309157, val_loss=0.76220286, val_CC_maskV_-1.0=0.50850999, val_MSE_maskV_-1.0=0.75917071, learning_rate=0.001\n", + "Epoch 51/243 - loss=0.66322535, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57927299, MSE_maskV_-1.0=0.66340697, val_loss=0.74029094, val_CC_maskV_-1.0=0.52821201, val_MSE_maskV_-1.0=0.73788756, learning_rate=0.001\n", + "Epoch 76/243 - loss=0.6507135, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58912975, MSE_maskV_-1.0=0.65087312, val_loss=0.72673684, val_CC_maskV_-1.0=0.53937626, val_MSE_maskV_-1.0=0.72470975, learning_rate=0.001\n", + "Epoch 101/243 - loss=0.64240754, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59614444, MSE_maskV_-1.0=0.64254957, val_loss=0.7271685, val_CC_maskV_-1.0=0.53987026, val_MSE_maskV_-1.0=0.72492683, learning_rate=0.001\n", + "Epoch 126/243 - loss=0.63662696, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60113698, MSE_maskV_-1.0=0.63693941, val_loss=0.72945279, val_CC_maskV_-1.0=0.53909045, val_MSE_maskV_-1.0=0.72701323, learning_rate=0.001\n", + "Epoch 151/243 - loss=0.63284963, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60357934, MSE_maskV_-1.0=0.63288707, val_loss=0.7175678, val_CC_maskV_-1.0=0.54686767, val_MSE_maskV_-1.0=0.71551931, learning_rate=0.001\n", + "Epoch 176/243 - loss=0.62896407, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60731041, MSE_maskV_-1.0=0.62913489, val_loss=0.71730906, val_CC_maskV_-1.0=0.54677284, val_MSE_maskV_-1.0=0.71509528, learning_rate=0.001\n", + "Epoch 201/243 - loss=0.62675363, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60841864, MSE_maskV_-1.0=0.62662917, val_loss=0.71411985, val_CC_maskV_-1.0=0.5496487, val_MSE_maskV_-1.0=0.71181816, learning_rate=0.001\n", + "Epoch 226/243 - loss=0.62350857, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61147928, MSE_maskV_-1.0=0.62362152, val_loss=0.7150436, val_CC_maskV_-1.0=0.54946011, val_MSE_maskV_-1.0=0.71296394, learning_rate=0.001\n", + "Epoch 243/243 - loss=0.62315822, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61204398, MSE_maskV_-1.0=0.62352192, val_loss=0.71447945, val_CC_maskV_-1.0=0.54795218, val_MSE_maskV_-1.0=0.71235651, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:44:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 63.42s\n", + "\u001b[32m2025-05-30 12:44:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:45:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 241 (stopped at 256 epochs).\n", + "\u001b[32m2025-05-30 12:45:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/257 - loss=1.4586202, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.13241185, MSE_maskV_-1.0=1.4580396, val_loss=1.0433316, val_CC_maskV_-1.0=0.20658733, val_MSE_maskV_-1.0=1.0360521, learning_rate=0.001\n", + "Epoch 27/257 - loss=0.69506049, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55135387, MSE_maskV_-1.0=0.69526428, val_loss=0.76194549, val_CC_maskV_-1.0=0.51308948, val_MSE_maskV_-1.0=0.75845128, learning_rate=0.001\n", + "Epoch 53/257 - loss=0.66549385, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57668877, MSE_maskV_-1.0=0.66525769, val_loss=0.73376006, val_CC_maskV_-1.0=0.53494954, val_MSE_maskV_-1.0=0.73059732, learning_rate=0.001\n", + "Epoch 79/257 - loss=0.6519087, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58735913, MSE_maskV_-1.0=0.65215242, val_loss=0.72991914, val_CC_maskV_-1.0=0.53799176, val_MSE_maskV_-1.0=0.72705245, learning_rate=0.001\n", + "Epoch 105/257 - loss=0.64452159, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59437209, MSE_maskV_-1.0=0.64440203, val_loss=0.72306478, val_CC_maskV_-1.0=0.54303384, val_MSE_maskV_-1.0=0.72033787, learning_rate=0.001\n", + "Epoch 131/257 - loss=0.63875455, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59792787, MSE_maskV_-1.0=0.63842046, val_loss=0.71981585, val_CC_maskV_-1.0=0.54595268, val_MSE_maskV_-1.0=0.71700168, learning_rate=0.001\n", + "Epoch 157/257 - loss=0.63411516, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60226059, MSE_maskV_-1.0=0.6335814, val_loss=0.71505046, val_CC_maskV_-1.0=0.54892892, val_MSE_maskV_-1.0=0.71255964, learning_rate=0.001\n", + "Epoch 183/257 - loss=0.62991136, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60566151, MSE_maskV_-1.0=0.62995762, val_loss=0.71344799, val_CC_maskV_-1.0=0.55263692, val_MSE_maskV_-1.0=0.71092623, learning_rate=0.001\n", + "Epoch 209/257 - loss=0.62589175, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60980046, MSE_maskV_-1.0=0.62656516, val_loss=0.70456123, val_CC_maskV_-1.0=0.55672735, val_MSE_maskV_-1.0=0.70245665, learning_rate=0.001\n", + "Epoch 235/257 - loss=0.62364548, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61083066, MSE_maskV_-1.0=0.62360626, val_loss=0.70623279, val_CC_maskV_-1.0=0.55517852, val_MSE_maskV_-1.0=0.70414972, learning_rate=0.001\n", + "Epoch 257/257 - loss=0.62249374, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61166722, MSE_maskV_-1.0=0.62234759, val_loss=0.70296931, val_CC_maskV_-1.0=0.55759937, val_MSE_maskV_-1.0=0.70082915, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:45:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 65.85s\n", + "\u001b[32m2025-05-30 12:45:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.70037144)\n", + "\u001b[32m2025-05-30 12:45:08\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 814us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:45:09\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.618, R2_maskV_-1.0=0.384, CC_maskV_-1.0=0.618\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 788us/step\n", + "51/51 [==============================] - 0s 853us/step\n", + "84/84 [==============================] - 0s 835us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:45:09\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_ACy1HL64U_ErSV16\" (8/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_ACy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:45:09\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_KCz1HL64U_ErSV16\" (9/16)\n", + "\u001b[32m2025-05-30 12:45:09\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:45:09\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:45:10\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:45:10\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:45:10\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:45:10\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:45:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:45:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 235 (stopped at 250 epochs).\n", + "\u001b[32m2025-05-30 12:45:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/251 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0059333, rnn_1step_R2_maskV_-1.0=-0.011364222, rnn_1step_CC_maskV_-1.0=0.014198383, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0908376, val_rnn_1step_R2_maskV_-1.0=-0.043684021, val_rnn_1step_CC_maskV_-1.0=0.15793814, learning_rate=0.001\n", + "Epoch 27/251 - loss=rnn_1step_loss=0.59703046, rnn_1step_R2_maskV_-1.0=0.3958804, rnn_1step_CC_maskV_-1.0=0.63740164, rnn_1step_MSE_maskV_-1.0=0.59703052, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.69389391, val_rnn_1step_R2_maskV_-1.0=0.326065, val_rnn_1step_CC_maskV_-1.0=0.59871542, learning_rate=0.001\n", + "Epoch 53/251 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37874499, rnn_1step_R2_maskV_-1.0=0.61416626, rnn_1step_CC_maskV_-1.0=0.78998744, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48173359, val_rnn_1step_R2_maskV_-1.0=0.53849196, val_rnn_1step_CC_maskV_-1.0=0.74289548, learning_rate=0.001\n", + "Epoch 79/251 - loss=rnn_1step_loss=0.30904493, rnn_1step_R2_maskV_-1.0=0.68502396, rnn_1step_CC_maskV_-1.0=0.83277464, rnn_1step_MSE_maskV_-1.0=0.3090449, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44532204, val_rnn_1step_R2_maskV_-1.0=0.57452428, val_rnn_1step_CC_maskV_-1.0=0.76613533, learning_rate=0.001\n", + "Epoch 105/251 - loss=rnn_1step_loss=0.28157127, rnn_1step_R2_maskV_-1.0=0.7118625, rnn_1step_CC_maskV_-1.0=0.84862989, rnn_1step_MSE_maskV_-1.0=0.2815713, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4428266, val_rnn_1step_R2_maskV_-1.0=0.57689548, val_rnn_1step_CC_maskV_-1.0=0.76751488, learning_rate=0.001\n", + "Epoch 131/251 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.24302697, rnn_1step_R2_maskV_-1.0=0.75211859, rnn_1step_CC_maskV_-1.0=0.87145209, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42896232, val_rnn_1step_R2_maskV_-1.0=0.59090739, val_rnn_1step_CC_maskV_-1.0=0.77629733, learning_rate=0.001\n", + "Epoch 157/251 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.22707283, rnn_1step_R2_maskV_-1.0=0.76913559, rnn_1step_CC_maskV_-1.0=0.88164139, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42572084, val_rnn_1step_R2_maskV_-1.0=0.5938369, val_rnn_1step_CC_maskV_-1.0=0.77780586, learning_rate=0.001\n", + "Epoch 183/251 - loss=rnn_1step_loss=0.20358336, rnn_1step_R2_maskV_-1.0=0.79181582, rnn_1step_CC_maskV_-1.0=0.89327478, rnn_1step_MSE_maskV_-1.0=0.20358334, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42655921, val_rnn_1step_R2_maskV_-1.0=0.59300989, val_rnn_1step_CC_maskV_-1.0=0.77822012, learning_rate=0.001\n", + "Epoch 209/251 - loss=rnn_1step_loss=0.18947178, rnn_1step_R2_maskV_-1.0=0.80606222, rnn_1step_CC_maskV_-1.0=0.90132815, rnn_1step_MSE_maskV_-1.0=0.18947177, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42132044, val_rnn_1step_R2_maskV_-1.0=0.59845304, val_rnn_1step_CC_maskV_-1.0=0.78192455, learning_rate=0.001\n", + "Epoch 235/251 - loss=rnn_1step_loss=0.17721851, rnn_1step_R2_maskV_-1.0=0.81888264, rnn_1step_CC_maskV_-1.0=0.90857625, rnn_1step_MSE_maskV_-1.0=0.17721853, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.41856551, val_rnn_1step_R2_maskV_-1.0=0.60129642, val_rnn_1step_CC_maskV_-1.0=0.78306752, learning_rate=0.001\n", + "Epoch 251/251 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.17053898, rnn_1step_R2_maskV_-1.0=0.82524025, rnn_1step_CC_maskV_-1.0=0.91171598, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42075232, val_rnn_1step_R2_maskV_-1.0=0.59929496, val_rnn_1step_CC_maskV_-1.0=0.78225815, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:45:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 26.61s\n", + "\u001b[32m2025-05-30 12:45:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:45:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 111 (stopped at 126 epochs).\n", + "\u001b[32m2025-05-30 12:45:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/127 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0058632, rnn_1_1step_R2_maskV_-1.0=-0.011290733, rnn_1_1step_CC_maskV_-1.0=0.052841417, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0909162, val_rnn_1_1step_R2_maskV_-1.0=-0.043781489, val_rnn_1_1step_CC_maskV_-1.0=0.15246862, learning_rate=0.001\n", + "Epoch 14/127 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.80411953, rnn_1_1step_R2_maskV_-1.0=0.18758583, rnn_1_1step_CC_maskV_-1.0=0.45635867, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.89234799, val_rnn_1_1step_R2_maskV_-1.0=0.14359735, val_rnn_1_1step_CC_maskV_-1.0=0.43773386, learning_rate=0.001\n", + "Epoch 27/127 - loss=rnn_1_1step_loss=0.54039615, rnn_1_1step_R2_maskV_-1.0=0.45011282, rnn_1_1step_CC_maskV_-1.0=0.67912287, rnn_1_1step_MSE_maskV_-1.0=0.54039609, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64720756, val_rnn_1_1step_R2_maskV_-1.0=0.38018686, val_rnn_1_1step_CC_maskV_-1.0=0.63571393, learning_rate=0.001\n", + "Epoch 40/127 - loss=rnn_1_1step_loss=0.45405254, rnn_1_1step_R2_maskV_-1.0=0.53696698, rnn_1_1step_CC_maskV_-1.0=0.74037814, rnn_1_1step_MSE_maskV_-1.0=0.45405248, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55424303, val_rnn_1_1step_R2_maskV_-1.0=0.4714269, val_rnn_1_1step_CC_maskV_-1.0=0.69727105, learning_rate=0.001\n", + "Epoch 53/127 - loss=rnn_1_1step_loss=0.40763667, rnn_1_1step_R2_maskV_-1.0=0.58344817, rnn_1_1step_CC_maskV_-1.0=0.77113974, rnn_1_1step_MSE_maskV_-1.0=0.4076367, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50765008, val_rnn_1_1step_R2_maskV_-1.0=0.51611745, val_rnn_1_1step_CC_maskV_-1.0=0.72706288, learning_rate=0.001\n", + "Epoch 66/127 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.37283611, rnn_1_1step_R2_maskV_-1.0=0.61841595, rnn_1_1step_CC_maskV_-1.0=0.79346985, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47865522, val_rnn_1_1step_R2_maskV_-1.0=0.54332846, val_rnn_1_1step_CC_maskV_-1.0=0.74505836, learning_rate=0.001\n", + "Epoch 79/127 - loss=rnn_1_1step_loss=0.33589649, rnn_1_1step_R2_maskV_-1.0=0.6557802, rnn_1_1step_CC_maskV_-1.0=0.81647217, rnn_1_1step_MSE_maskV_-1.0=0.33589646, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4436262, val_rnn_1_1step_R2_maskV_-1.0=0.57621682, val_rnn_1_1step_CC_maskV_-1.0=0.76643306, learning_rate=0.001\n", + "Epoch 92/127 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30483994, rnn_1_1step_R2_maskV_-1.0=0.68745631, rnn_1_1step_CC_maskV_-1.0=0.83502579, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.42497277, val_rnn_1_1step_R2_maskV_-1.0=0.59347701, val_rnn_1_1step_CC_maskV_-1.0=0.77813172, learning_rate=0.001\n", + "Epoch 105/127 - loss=rnn_1_1step_loss=0.28516874, rnn_1_1step_R2_maskV_-1.0=0.70793366, rnn_1_1step_CC_maskV_-1.0=0.84646273, rnn_1_1step_MSE_maskV_-1.0=0.28516877, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.42457485, val_rnn_1_1step_R2_maskV_-1.0=0.59341389, val_rnn_1_1step_CC_maskV_-1.0=0.77893317, learning_rate=0.001\n", + "Epoch 118/127 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.25823978, rnn_1_1step_R2_maskV_-1.0=0.73542327, rnn_1_1step_CC_maskV_-1.0=0.86208147, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.42287871, val_rnn_1_1step_R2_maskV_-1.0=0.59498024, val_rnn_1_1step_CC_maskV_-1.0=0.78126967, learning_rate=0.001\n", + "Epoch 127/127 - loss=rnn_1_1step_loss=0.24892569, rnn_1_1step_R2_maskV_-1.0=0.74476826, rnn_1_1step_CC_maskV_-1.0=0.86721671, rnn_1_1step_MSE_maskV_-1.0=0.2489257, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.42892146, val_rnn_1_1step_R2_maskV_-1.0=0.58915538, val_rnn_1_1step_CC_maskV_-1.0=0.77822143, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:45:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.69s\n", + "\u001b[32m2025-05-30 12:45:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.41856551)\n", + "\u001b[32m2025-05-30 12:45:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.167, R2_maskV_-1.0=0.832, CC_maskV_-1.0=0.913\n", + "\u001b[32m2025-05-30 12:45:53\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.386, R2_maskV_-1.0=0.625, CC_maskV_-1.0=0.798\n", + "\u001b[32m2025-05-30 12:45:53\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:45:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:46:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 183 (stopped at 198 epochs).\n", + "\u001b[32m2025-05-30 12:46:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/199 - loss=4.6670766, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0026270344, MSE_maskV_-1.0=4.6582012, val_loss=1.4696342, val_CC_maskV_-1.0=0.011421201, val_MSE_maskV_-1.0=1.4597492, learning_rate=0.001\n", + "Epoch 21/199 - loss=0.88092184, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34607494, MSE_maskV_-1.0=0.88090515, val_loss=0.94408762, val_CC_maskV_-1.0=0.33400446, val_MSE_maskV_-1.0=0.93966818, learning_rate=0.001\n", + "Epoch 41/199 - loss=0.85585707, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3803052, MSE_maskV_-1.0=0.85558283, val_loss=0.91997546, val_CC_maskV_-1.0=0.36398634, val_MSE_maskV_-1.0=0.91626436, learning_rate=0.001\n", + "Epoch 61/199 - loss=0.84329075, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39723971, MSE_maskV_-1.0=0.84333211, val_loss=0.91038334, val_CC_maskV_-1.0=0.37543097, val_MSE_maskV_-1.0=0.9067508, learning_rate=0.001\n", + "Epoch 81/199 - loss=0.83521825, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40670177, MSE_maskV_-1.0=0.83516866, val_loss=0.89655417, val_CC_maskV_-1.0=0.39181146, val_MSE_maskV_-1.0=0.89328092, learning_rate=0.001\n", + "Epoch 101/199 - loss=0.82813561, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41587916, MSE_maskV_-1.0=0.82819235, val_loss=0.89228827, val_CC_maskV_-1.0=0.3974624, val_MSE_maskV_-1.0=0.88891071, learning_rate=0.001\n", + "Epoch 121/199 - loss=0.82260764, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42292339, MSE_maskV_-1.0=0.82308012, val_loss=0.88748682, val_CC_maskV_-1.0=0.40249857, val_MSE_maskV_-1.0=0.8841936, learning_rate=0.001\n", + "Epoch 141/199 - loss=0.81796926, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42868504, MSE_maskV_-1.0=0.81788576, val_loss=0.88507664, val_CC_maskV_-1.0=0.40525419, val_MSE_maskV_-1.0=0.88165194, learning_rate=0.001\n", + "Epoch 161/199 - loss=0.81475979, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43147823, MSE_maskV_-1.0=0.81503385, val_loss=0.88388151, val_CC_maskV_-1.0=0.40610456, val_MSE_maskV_-1.0=0.88062692, learning_rate=0.001\n", + "Epoch 181/199 - loss=0.81162685, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43556958, MSE_maskV_-1.0=0.81123555, val_loss=0.87621117, val_CC_maskV_-1.0=0.41469982, val_MSE_maskV_-1.0=0.87303841, learning_rate=0.001\n", + "Epoch 199/199 - loss=0.80933052, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43819746, MSE_maskV_-1.0=0.80853778, val_loss=0.87517238, val_CC_maskV_-1.0=0.41658127, val_MSE_maskV_-1.0=0.87185699, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:46:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 48.15s\n", + "\u001b[32m2025-05-30 12:46:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:47:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 183 (stopped at 198 epochs).\n", + "\u001b[32m2025-05-30 12:47:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/199 - loss=5.5781794, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.017351674, MSE_maskV_-1.0=5.5671582, val_loss=1.6674249, val_CC_maskV_-1.0=0.045359302, val_MSE_maskV_-1.0=1.6520932, learning_rate=0.001\n", + "Epoch 21/199 - loss=0.88267154, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34340763, MSE_maskV_-1.0=0.88258165, val_loss=0.94697529, val_CC_maskV_-1.0=0.32997665, val_MSE_maskV_-1.0=0.94227904, learning_rate=0.001\n", + "Epoch 41/199 - loss=0.85796851, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37743419, MSE_maskV_-1.0=0.85771537, val_loss=0.92367828, val_CC_maskV_-1.0=0.35921302, val_MSE_maskV_-1.0=0.91990387, learning_rate=0.001\n", + "Epoch 61/199 - loss=0.84537554, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39452836, MSE_maskV_-1.0=0.84541047, val_loss=0.9127866, val_CC_maskV_-1.0=0.37260216, val_MSE_maskV_-1.0=0.90919465, learning_rate=0.001\n", + "Epoch 81/199 - loss=0.8372004, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40411335, MSE_maskV_-1.0=0.83717245, val_loss=0.89966297, val_CC_maskV_-1.0=0.38784009, val_MSE_maskV_-1.0=0.89641297, learning_rate=0.001\n", + "Epoch 101/199 - loss=0.83007264, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41350886, MSE_maskV_-1.0=0.83011246, val_loss=0.89482135, val_CC_maskV_-1.0=0.39435783, val_MSE_maskV_-1.0=0.89148974, learning_rate=0.001\n", + "Epoch 121/199 - loss=0.82443249, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42062947, MSE_maskV_-1.0=0.82487357, val_loss=0.89026874, val_CC_maskV_-1.0=0.39895424, val_MSE_maskV_-1.0=0.88700056, learning_rate=0.001\n", + "Epoch 141/199 - loss=0.81970328, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42655888, MSE_maskV_-1.0=0.81961209, val_loss=0.88699186, val_CC_maskV_-1.0=0.4028765, val_MSE_maskV_-1.0=0.88360006, learning_rate=0.001\n", + "Epoch 161/199 - loss=0.81644458, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4294214, MSE_maskV_-1.0=0.81671202, val_loss=0.88606405, val_CC_maskV_-1.0=0.4034785, val_MSE_maskV_-1.0=0.8828333, learning_rate=0.001\n", + "Epoch 181/199 - loss=0.81319886, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43370038, MSE_maskV_-1.0=0.81282133, val_loss=0.87829733, val_CC_maskV_-1.0=0.41216436, val_MSE_maskV_-1.0=0.87514603, learning_rate=0.001\n", + "Epoch 199/199 - loss=0.81086206, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43640211, MSE_maskV_-1.0=0.81006175, val_loss=0.87703812, val_CC_maskV_-1.0=0.41433728, val_MSE_maskV_-1.0=0.87375045, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:47:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 47.83s\n", + "\u001b[32m2025-05-30 12:47:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.87331527)\n", + "\u001b[32m2025-05-30 12:47:29\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 751us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:47:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.812, R2_maskV_-1.0=0.186, CC_maskV_-1.0=0.434\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 738us/step\n", + "51/51 [==============================] - 0s 794us/step\n", + "84/84 [==============================] - 0s 686us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:47:30\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_KCz1HL64U_ErSV16\" (9/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_KCz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:47:30\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_KCy1HL64U_ErSV16\" (10/16)\n", + "\u001b[32m2025-05-30 12:47:30\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:47:30\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:47:30\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:47:30\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:47:30\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:47:30\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:47:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:47:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 84 (stopped at 99 epochs).\n", + "\u001b[32m2025-05-30 12:47:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/100 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0054805, rnn_1step_R2_maskV_-1.0=-0.010868594, rnn_1step_CC_maskV_-1.0=0.058268726, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.089955, val_rnn_1step_R2_maskV_-1.0=-0.042874858, val_rnn_1step_CC_maskV_-1.0=0.097012199, learning_rate=0.001\n", + "Epoch 11/100 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.84624767, rnn_1step_R2_maskV_-1.0=0.14724803, rnn_1step_CC_maskV_-1.0=0.41566479, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91064358, val_rnn_1step_R2_maskV_-1.0=0.12780368, val_rnn_1step_CC_maskV_-1.0=0.40356824, learning_rate=0.001\n", + "Epoch 21/100 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.57581353, rnn_1step_R2_maskV_-1.0=0.41543567, rnn_1step_CC_maskV_-1.0=0.65242869, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6638245, val_rnn_1step_R2_maskV_-1.0=0.36126518, val_rnn_1step_CC_maskV_-1.0=0.62456131, learning_rate=0.001\n", + "Epoch 31/100 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.45441845, rnn_1step_R2_maskV_-1.0=0.53725207, rnn_1step_CC_maskV_-1.0=0.73990202, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53929275, val_rnn_1step_R2_maskV_-1.0=0.48202819, val_rnn_1step_CC_maskV_-1.0=0.70675939, learning_rate=0.001\n", + "Epoch 41/100 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39120066, rnn_1step_R2_maskV_-1.0=0.60118473, rnn_1step_CC_maskV_-1.0=0.78156447, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47023427, val_rnn_1step_R2_maskV_-1.0=0.55019939, val_rnn_1step_CC_maskV_-1.0=0.75022036, learning_rate=0.001\n", + "Epoch 51/100 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34541956, rnn_1step_R2_maskV_-1.0=0.64830077, rnn_1step_CC_maskV_-1.0=0.81022263, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44546279, val_rnn_1step_R2_maskV_-1.0=0.57361901, val_rnn_1step_CC_maskV_-1.0=0.76587039, learning_rate=0.001\n", + "Epoch 61/100 - loss=rnn_1step_loss=0.29449067, rnn_1step_R2_maskV_-1.0=0.70100814, rnn_1step_CC_maskV_-1.0=0.84101522, rnn_1step_MSE_maskV_-1.0=0.29449064, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42699277, val_rnn_1step_R2_maskV_-1.0=0.5901444, val_rnn_1step_CC_maskV_-1.0=0.77741039, learning_rate=0.001\n", + "Epoch 71/100 - loss=rnn_1step_loss=0.27090719, rnn_1step_R2_maskV_-1.0=0.72505879, rnn_1step_CC_maskV_-1.0=0.85475504, rnn_1step_MSE_maskV_-1.0=0.27090722, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42432246, val_rnn_1step_R2_maskV_-1.0=0.59232044, val_rnn_1step_CC_maskV_-1.0=0.77902454, learning_rate=0.001\n", + "Epoch 81/100 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.25662336, rnn_1step_R2_maskV_-1.0=0.73963845, rnn_1step_CC_maskV_-1.0=0.8630116, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42256212, val_rnn_1step_R2_maskV_-1.0=0.59409475, val_rnn_1step_CC_maskV_-1.0=0.78025973, learning_rate=0.001\n", + "Epoch 91/100 - loss=rnn_1step_loss=0.2467965, rnn_1step_R2_maskV_-1.0=0.74972045, rnn_1step_CC_maskV_-1.0=0.86872864, rnn_1step_MSE_maskV_-1.0=0.24679649, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42303944, val_rnn_1step_R2_maskV_-1.0=0.59380108, val_rnn_1step_CC_maskV_-1.0=0.78095686, learning_rate=0.001\n", + "Epoch 100/100 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.23829667, rnn_1step_R2_maskV_-1.0=0.75796622, rnn_1step_CC_maskV_-1.0=0.87361348, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42833462, val_rnn_1step_R2_maskV_-1.0=0.58868128, val_rnn_1step_CC_maskV_-1.0=0.77868271, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:47:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 11.19s\n", + "\u001b[32m2025-05-30 12:47:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:47:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 92 (stopped at 107 epochs).\n", + "\u001b[32m2025-05-30 12:47:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/108 - loss=rnn_1_1step_loss=1.005128, rnn_1_1step_R2_maskV_-1.0=-0.010520834, rnn_1_1step_CC_maskV_-1.0=0.11237112, rnn_1_1step_MSE_maskV_-1.0=1.0051279, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0889434, val_rnn_1_1step_R2_maskV_-1.0=-0.041888535, val_rnn_1_1step_CC_maskV_-1.0=0.23656416, learning_rate=0.001\n", + "Epoch 12/108 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.85293913, rnn_1_1step_R2_maskV_-1.0=0.13786641, rnn_1_1step_CC_maskV_-1.0=0.3896957, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92583686, val_rnn_1_1step_R2_maskV_-1.0=0.11342403, val_rnn_1_1step_CC_maskV_-1.0=0.39552191, learning_rate=0.001\n", + "Epoch 23/108 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.58107656, rnn_1_1step_R2_maskV_-1.0=0.40897465, rnn_1_1step_CC_maskV_-1.0=0.64819461, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.68024492, val_rnn_1_1step_R2_maskV_-1.0=0.34537965, val_rnn_1_1step_CC_maskV_-1.0=0.6134454, learning_rate=0.001\n", + "Epoch 34/108 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.45220628, rnn_1_1step_R2_maskV_-1.0=0.53908002, rnn_1_1step_CC_maskV_-1.0=0.74098635, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52750969, val_rnn_1_1step_R2_maskV_-1.0=0.49346945, val_rnn_1_1step_CC_maskV_-1.0=0.71511561, learning_rate=0.001\n", + "Epoch 45/108 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38007483, rnn_1_1step_R2_maskV_-1.0=0.61325252, rnn_1_1step_CC_maskV_-1.0=0.78860891, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45850268, val_rnn_1_1step_R2_maskV_-1.0=0.56062341, val_rnn_1_1step_CC_maskV_-1.0=0.75815099, learning_rate=0.001\n", + "Epoch 56/108 - loss=rnn_1_1step_loss=0.33205435, rnn_1_1step_R2_maskV_-1.0=0.66312742, rnn_1_1step_CC_maskV_-1.0=0.81865758, rnn_1_1step_MSE_maskV_-1.0=0.33205432, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45127177, val_rnn_1_1step_R2_maskV_-1.0=0.5670839, val_rnn_1_1step_CC_maskV_-1.0=0.76291358, learning_rate=0.001\n", + "Epoch 67/108 - loss=rnn_1_1step_loss=0.29262993, rnn_1_1step_R2_maskV_-1.0=0.70333493, rnn_1_1step_CC_maskV_-1.0=0.84248602, rnn_1_1step_MSE_maskV_-1.0=0.2926299, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.43759355, val_rnn_1_1step_R2_maskV_-1.0=0.57964194, val_rnn_1_1step_CC_maskV_-1.0=0.77092773, learning_rate=0.001\n", + "Epoch 78/108 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.26878586, rnn_1_1step_R2_maskV_-1.0=0.72715187, rnn_1_1step_CC_maskV_-1.0=0.85645723, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4277918, val_rnn_1_1step_R2_maskV_-1.0=0.58881009, val_rnn_1_1step_CC_maskV_-1.0=0.77665055, learning_rate=0.001\n", + "Epoch 89/108 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.25442481, rnn_1_1step_R2_maskV_-1.0=0.74141252, rnn_1_1step_CC_maskV_-1.0=0.864636, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.42543492, val_rnn_1_1step_R2_maskV_-1.0=0.59139848, val_rnn_1_1step_CC_maskV_-1.0=0.77813089, learning_rate=0.001\n", + "Epoch 100/108 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.2422384, rnn_1_1step_R2_maskV_-1.0=0.75363898, rnn_1_1step_CC_maskV_-1.0=0.87153351, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41743127, val_rnn_1_1step_R2_maskV_-1.0=0.5987221, val_rnn_1_1step_CC_maskV_-1.0=0.78287357, learning_rate=0.001\n", + "Epoch 108/108 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.23447371, rnn_1_1step_R2_maskV_-1.0=0.7613371, rnn_1_1step_CC_maskV_-1.0=0.87590486, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41535568, val_rnn_1_1step_R2_maskV_-1.0=0.6005106, val_rnn_1_1step_CC_maskV_-1.0=0.78409696, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:47:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 11.80s\n", + "\u001b[32m2025-05-30 12:47:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.41374969)\n", + "\u001b[32m2025-05-30 12:47:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.214, R2_maskV_-1.0=0.786, CC_maskV_-1.0=0.887\n", + "\u001b[32m2025-05-30 12:47:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.385, R2_maskV_-1.0=0.623, CC_maskV_-1.0=0.798\n", + "\u001b[32m2025-05-30 12:47:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:47:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:48:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 168 (stopped at 183 epochs).\n", + "\u001b[32m2025-05-30 12:48:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/184 - loss=1.1749154, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.10666271, MSE_maskV_-1.0=1.1756521, val_loss=1.0401371, val_CC_maskV_-1.0=0.15809751, val_MSE_maskV_-1.0=1.0364331, learning_rate=0.001\n", + "Epoch 20/184 - loss=0.81642687, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43066183, MSE_maskV_-1.0=0.81656832, val_loss=0.89539838, val_CC_maskV_-1.0=0.39143053, val_MSE_maskV_-1.0=0.89226013, learning_rate=0.001\n", + "Epoch 39/184 - loss=0.77927244, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47170267, MSE_maskV_-1.0=0.77887452, val_loss=0.86148161, val_CC_maskV_-1.0=0.42921537, val_MSE_maskV_-1.0=0.85894346, learning_rate=0.001\n", + "Epoch 58/184 - loss=0.75869089, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49303469, MSE_maskV_-1.0=0.7584042, val_loss=0.84179723, val_CC_maskV_-1.0=0.44477186, val_MSE_maskV_-1.0=0.83915794, learning_rate=0.001\n", + "Epoch 77/184 - loss=0.74743176, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50371933, MSE_maskV_-1.0=0.7474767, val_loss=0.83133477, val_CC_maskV_-1.0=0.45461756, val_MSE_maskV_-1.0=0.82886791, learning_rate=0.001\n", + "Epoch 96/184 - loss=0.73885292, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51189429, MSE_maskV_-1.0=0.73869693, val_loss=0.81993723, val_CC_maskV_-1.0=0.46555769, val_MSE_maskV_-1.0=0.8178494, learning_rate=0.001\n", + "Epoch 115/184 - loss=0.73354059, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51667708, MSE_maskV_-1.0=0.73296916, val_loss=0.81813061, val_CC_maskV_-1.0=0.467457, val_MSE_maskV_-1.0=0.81587416, learning_rate=0.001\n", + "Epoch 134/184 - loss=0.7275098, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52294999, MSE_maskV_-1.0=0.72734207, val_loss=0.81326109, val_CC_maskV_-1.0=0.47200432, val_MSE_maskV_-1.0=0.8106398, learning_rate=0.001\n", + "Epoch 153/184 - loss=0.72502929, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52430248, MSE_maskV_-1.0=0.72514117, val_loss=0.8058666, val_CC_maskV_-1.0=0.4759343, val_MSE_maskV_-1.0=0.80344117, learning_rate=0.001\n", + "Epoch 172/184 - loss=0.72073156, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52841848, MSE_maskV_-1.0=0.72066396, val_loss=0.81525016, val_CC_maskV_-1.0=0.46767026, val_MSE_maskV_-1.0=0.81278116, learning_rate=0.001\n", + "Epoch 184/184 - loss=0.72066933, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52858925, MSE_maskV_-1.0=0.72522968, val_loss=0.80645072, val_CC_maskV_-1.0=0.4768829, val_MSE_maskV_-1.0=0.80357546, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:48:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 48.61s\n", + "\u001b[32m2025-05-30 12:48:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:49:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 137 (stopped at 152 epochs).\n", + "\u001b[32m2025-05-30 12:49:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/153 - loss=1.212783, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.093478881, MSE_maskV_-1.0=1.2133819, val_loss=1.038736, val_CC_maskV_-1.0=0.16007423, val_MSE_maskV_-1.0=1.0325603, learning_rate=0.001\n", + "Epoch 17/153 - loss=0.82800484, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41623774, MSE_maskV_-1.0=0.82940817, val_loss=0.90625256, val_CC_maskV_-1.0=0.37895003, val_MSE_maskV_-1.0=0.90343308, learning_rate=0.001\n", + "Epoch 33/153 - loss=0.78739047, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46324268, MSE_maskV_-1.0=0.78677893, val_loss=0.86486191, val_CC_maskV_-1.0=0.42452225, val_MSE_maskV_-1.0=0.86227846, learning_rate=0.001\n", + "Epoch 49/153 - loss=0.76533085, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48590213, MSE_maskV_-1.0=0.76495302, val_loss=0.84270066, val_CC_maskV_-1.0=0.44716224, val_MSE_maskV_-1.0=0.84000474, learning_rate=0.001\n", + "Epoch 65/153 - loss=0.75100094, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49986392, MSE_maskV_-1.0=0.75040758, val_loss=0.83023202, val_CC_maskV_-1.0=0.45556888, val_MSE_maskV_-1.0=0.82778805, learning_rate=0.001\n", + "Epoch 81/153 - loss=0.74166089, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50807226, MSE_maskV_-1.0=0.74157381, val_loss=0.82039028, val_CC_maskV_-1.0=0.46586964, val_MSE_maskV_-1.0=0.81818968, learning_rate=0.001\n", + "Epoch 97/153 - loss=0.73501444, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5151239, MSE_maskV_-1.0=0.73493588, val_loss=0.81600732, val_CC_maskV_-1.0=0.46969458, val_MSE_maskV_-1.0=0.81384414, learning_rate=0.001\n", + "Epoch 113/153 - loss=0.73083681, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5195387, MSE_maskV_-1.0=0.73100495, val_loss=0.8151871, val_CC_maskV_-1.0=0.46986216, val_MSE_maskV_-1.0=0.81305498, learning_rate=0.001\n", + "Epoch 129/153 - loss=0.72635961, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52341133, MSE_maskV_-1.0=0.72631752, val_loss=0.81194377, val_CC_maskV_-1.0=0.47268778, val_MSE_maskV_-1.0=0.80969256, learning_rate=0.001\n", + "Epoch 145/153 - loss=0.72444224, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52496922, MSE_maskV_-1.0=0.72438931, val_loss=0.8055132, val_CC_maskV_-1.0=0.4775027, val_MSE_maskV_-1.0=0.80412447, learning_rate=0.001\n", + "Epoch 153/153 - loss=0.72258407, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52670056, MSE_maskV_-1.0=0.72265148, val_loss=0.80234045, val_CC_maskV_-1.0=0.47856209, val_MSE_maskV_-1.0=0.8010301, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:49:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 40.78s\n", + "\u001b[32m2025-05-30 12:49:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.80069208)\n", + "\u001b[32m2025-05-30 12:49:26\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 931us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:49:26\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.716, R2_maskV_-1.0=0.284, CC_maskV_-1.0=0.534\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 909us/step\n", + "51/51 [==============================] - 0s 1ms/step\n", + "84/84 [==============================] - 0s 865us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:49:27\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_KCy1HL64U_ErSV16\" (10/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_KCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:49:27\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_CzCy1HL64U_ErSV16\" (11/16)\n", + "\u001b[32m2025-05-30 12:49:27\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_CzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:49:27\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:49:27\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:49:28\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:49:28\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:49:28\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:49:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:50:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 352 (stopped at 367 epochs).\n", + "\u001b[32m2025-05-30 12:50:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/368 - loss=rnn_1step_loss=1.0052472, rnn_1step_R2_maskV_-1.0=-0.010648567, rnn_1step_CC_maskV_-1.0=0.091766953, rnn_1step_MSE_maskV_-1.0=1.0052474, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.088991, val_rnn_1step_R2_maskV_-1.0=-0.041933343, val_rnn_1step_CC_maskV_-1.0=0.19905779, learning_rate=0.001\n", + "Epoch 38/368 - loss=rnn_1step_loss=0.54241967, rnn_1step_R2_maskV_-1.0=0.45060611, rnn_1step_CC_maskV_-1.0=0.67843622, rnn_1step_MSE_maskV_-1.0=0.54241973, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60969234, val_rnn_1step_R2_maskV_-1.0=0.41454887, val_rnn_1step_CC_maskV_-1.0=0.66234791, learning_rate=0.001\n", + "Epoch 75/368 - loss=rnn_1step_loss=0.42776641, rnn_1step_R2_maskV_-1.0=0.56274879, rnn_1step_CC_maskV_-1.0=0.75806987, rnn_1step_MSE_maskV_-1.0=0.42776644, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46356001, val_rnn_1step_R2_maskV_-1.0=0.55463958, val_rnn_1step_CC_maskV_-1.0=0.75742352, learning_rate=0.001\n", + "Epoch 112/368 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40352392, rnn_1step_R2_maskV_-1.0=0.58688307, rnn_1step_CC_maskV_-1.0=0.77369463, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45086017, val_rnn_1step_R2_maskV_-1.0=0.56603158, val_rnn_1step_CC_maskV_-1.0=0.76458615, learning_rate=0.001\n", + "Epoch 149/368 - loss=rnn_1step_loss=0.38726792, rnn_1step_R2_maskV_-1.0=0.60358202, rnn_1step_CC_maskV_-1.0=0.78407609, rnn_1step_MSE_maskV_-1.0=0.38726795, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44763997, val_rnn_1step_R2_maskV_-1.0=0.56876361, val_rnn_1step_CC_maskV_-1.0=0.76674718, learning_rate=0.001\n", + "Epoch 186/368 - loss=rnn_1step_loss=0.37035394, rnn_1step_R2_maskV_-1.0=0.62112784, rnn_1step_CC_maskV_-1.0=0.79482186, rnn_1step_MSE_maskV_-1.0=0.37035391, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44474187, val_rnn_1step_R2_maskV_-1.0=0.57162911, val_rnn_1step_CC_maskV_-1.0=0.76877111, learning_rate=0.001\n", + "Epoch 223/368 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35125074, rnn_1step_R2_maskV_-1.0=0.64089108, rnn_1step_CC_maskV_-1.0=0.80678171, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.43767285, val_rnn_1step_R2_maskV_-1.0=0.57870871, val_rnn_1step_CC_maskV_-1.0=0.77272022, learning_rate=0.001\n", + "Epoch 260/368 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33420715, rnn_1step_R2_maskV_-1.0=0.65827131, rnn_1step_CC_maskV_-1.0=0.81727576, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42762101, val_rnn_1step_R2_maskV_-1.0=0.58883905, val_rnn_1step_CC_maskV_-1.0=0.77792507, learning_rate=0.001\n", + "Epoch 297/368 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32399759, rnn_1step_R2_maskV_-1.0=0.66841018, rnn_1step_CC_maskV_-1.0=0.82349086, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.41723874, val_rnn_1step_R2_maskV_-1.0=0.59904665, val_rnn_1step_CC_maskV_-1.0=0.78356016, learning_rate=0.001\n", + "Epoch 334/368 - loss=rnn_1step_loss=0.31718561, rnn_1step_R2_maskV_-1.0=0.67505729, rnn_1step_CC_maskV_-1.0=0.82767999, rnn_1step_MSE_maskV_-1.0=0.31718564, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.40880099, val_rnn_1step_R2_maskV_-1.0=0.606942, val_rnn_1step_CC_maskV_-1.0=0.7884025, learning_rate=0.001\n", + "Epoch 368/368 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31109691, rnn_1step_R2_maskV_-1.0=0.68106031, rnn_1step_CC_maskV_-1.0=0.83136338, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.40749311, val_rnn_1step_R2_maskV_-1.0=0.60816312, val_rnn_1step_CC_maskV_-1.0=0.78919256, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:50:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 35.43s\n", + "\u001b[32m2025-05-30 12:50:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:50:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 366 (stopped at 381 epochs).\n", + "\u001b[32m2025-05-30 12:50:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/382 - loss=rnn_1_1step_loss=1.0053812, rnn_1_1step_R2_maskV_-1.0=-0.01077231, rnn_1_1step_CC_maskV_-1.0=0.087909229, rnn_1_1step_MSE_maskV_-1.0=1.0053813, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0896273, val_rnn_1_1step_R2_maskV_-1.0=-0.042612761, val_rnn_1_1step_CC_maskV_-1.0=0.18841499, learning_rate=0.001\n", + "Epoch 40/382 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.48035416, rnn_1_1step_R2_maskV_-1.0=0.51064539, rnn_1_1step_CC_maskV_-1.0=0.72193432, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53342873, val_rnn_1_1step_R2_maskV_-1.0=0.48834622, val_rnn_1_1step_CC_maskV_-1.0=0.71262097, learning_rate=0.001\n", + "Epoch 79/382 - loss=rnn_1_1step_loss=0.41396102, rnn_1_1step_R2_maskV_-1.0=0.57649767, rnn_1_1step_CC_maskV_-1.0=0.76684815, rnn_1_1step_MSE_maskV_-1.0=0.41396099, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45408714, val_rnn_1_1step_R2_maskV_-1.0=0.56370759, val_rnn_1_1step_CC_maskV_-1.0=0.76337373, learning_rate=0.001\n", + "Epoch 118/382 - loss=rnn_1_1step_loss=0.38036075, rnn_1_1step_R2_maskV_-1.0=0.61106175, rnn_1_1step_CC_maskV_-1.0=0.7885139, rnn_1_1step_MSE_maskV_-1.0=0.38036072, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.44716287, val_rnn_1_1step_R2_maskV_-1.0=0.56999123, val_rnn_1_1step_CC_maskV_-1.0=0.76709729, learning_rate=0.001\n", + "Epoch 157/382 - loss=rnn_1_1step_loss=0.34938154, rnn_1_1step_R2_maskV_-1.0=0.64274144, rnn_1_1step_CC_maskV_-1.0=0.80787337, rnn_1_1step_MSE_maskV_-1.0=0.34938148, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.42493844, val_rnn_1_1step_R2_maskV_-1.0=0.59188485, val_rnn_1_1step_CC_maskV_-1.0=0.77970463, learning_rate=0.001\n", + "Epoch 196/382 - loss=rnn_1_1step_loss=0.33888316, rnn_1_1step_R2_maskV_-1.0=0.65306067, rnn_1_1step_CC_maskV_-1.0=0.81437486, rnn_1_1step_MSE_maskV_-1.0=0.33888313, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41401422, val_rnn_1_1step_R2_maskV_-1.0=0.60276592, val_rnn_1_1step_CC_maskV_-1.0=0.78614736, learning_rate=0.001\n", + "Epoch 235/382 - loss=rnn_1_1step_loss=0.33204749, rnn_1_1step_R2_maskV_-1.0=0.65974927, rnn_1_1step_CC_maskV_-1.0=0.81859523, rnn_1_1step_MSE_maskV_-1.0=0.33204752, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.40777025, val_rnn_1_1step_R2_maskV_-1.0=0.6086719, val_rnn_1_1step_CC_maskV_-1.0=0.78966308, learning_rate=0.001\n", + "Epoch 274/382 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32584751, rnn_1_1step_R2_maskV_-1.0=0.66577089, rnn_1_1step_CC_maskV_-1.0=0.82239246, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.40459833, val_rnn_1_1step_R2_maskV_-1.0=0.61165398, val_rnn_1_1step_CC_maskV_-1.0=0.79139382, learning_rate=0.001\n", + "Epoch 313/382 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31985354, rnn_1_1step_R2_maskV_-1.0=0.67163825, rnn_1_1step_CC_maskV_-1.0=0.82605535, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.40290716, val_rnn_1_1step_R2_maskV_-1.0=0.61330903, val_rnn_1_1step_CC_maskV_-1.0=0.79223114, learning_rate=0.001\n", + "Epoch 352/382 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31501555, rnn_1_1step_R2_maskV_-1.0=0.67631137, rnn_1_1step_CC_maskV_-1.0=0.82892239, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.40492925, val_rnn_1_1step_R2_maskV_-1.0=0.61175454, val_rnn_1_1step_CC_maskV_-1.0=0.7908873, learning_rate=0.001\n", + "Epoch 382/382 - loss=rnn_1_1step_loss=0.31041339, rnn_1_1step_R2_maskV_-1.0=0.68096673, rnn_1_1step_CC_maskV_-1.0=0.83176243, rnn_1_1step_MSE_maskV_-1.0=0.31041336, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.39845166, val_rnn_1_1step_R2_maskV_-1.0=0.61759996, val_rnn_1_1step_CC_maskV_-1.0=0.79450727, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:50:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 37.10s\n", + "\u001b[32m2025-05-30 12:50:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.39732656)\n", + "\u001b[32m2025-05-30 12:50:42\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.276, R2_maskV_-1.0=0.724, CC_maskV_-1.0=0.851\n", + "\u001b[32m2025-05-30 12:50:42\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.377, R2_maskV_-1.0=0.63, CC_maskV_-1.0=0.803\n", + "\u001b[32m2025-05-30 12:50:42\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:50:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:51:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 149 (stopped at 164 epochs).\n", + "\u001b[32m2025-05-30 12:51:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/165 - loss=4.1702023, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.035051435, MSE_maskV_-1.0=4.1628656, val_loss=1.3665415, val_CC_maskV_-1.0=0.057880949, val_MSE_maskV_-1.0=1.3579749, learning_rate=0.001\n", + "Epoch 18/165 - loss=0.75471693, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49500632, MSE_maskV_-1.0=0.75479674, val_loss=0.82775074, val_CC_maskV_-1.0=0.46159205, val_MSE_maskV_-1.0=0.82473141, learning_rate=0.001\n", + "Epoch 35/165 - loss=0.68886286, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55725688, MSE_maskV_-1.0=0.68880123, val_loss=0.76019984, val_CC_maskV_-1.0=0.52091587, val_MSE_maskV_-1.0=0.75719595, learning_rate=0.001\n", + "Epoch 52/165 - loss=0.65744376, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58471024, MSE_maskV_-1.0=0.65741026, val_loss=0.73185325, val_CC_maskV_-1.0=0.54529077, val_MSE_maskV_-1.0=0.72874588, learning_rate=0.001\n", + "Epoch 69/165 - loss=0.64671558, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59353203, MSE_maskV_-1.0=0.64666522, val_loss=0.71818662, val_CC_maskV_-1.0=0.55249369, val_MSE_maskV_-1.0=0.71493834, learning_rate=0.001\n", + "Epoch 86/165 - loss=0.63887757, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59973788, MSE_maskV_-1.0=0.6392259, val_loss=0.71129215, val_CC_maskV_-1.0=0.56027985, val_MSE_maskV_-1.0=0.70813727, learning_rate=0.001\n", + "Epoch 103/165 - loss=0.63363469, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60429573, MSE_maskV_-1.0=0.63368642, val_loss=0.70250505, val_CC_maskV_-1.0=0.56662989, val_MSE_maskV_-1.0=0.69938964, learning_rate=0.001\n", + "Epoch 120/165 - loss=0.62836027, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60818756, MSE_maskV_-1.0=0.62815547, val_loss=0.70589662, val_CC_maskV_-1.0=0.56351268, val_MSE_maskV_-1.0=0.70291251, learning_rate=0.001\n", + "Epoch 137/165 - loss=0.62533933, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61025339, MSE_maskV_-1.0=0.62467247, val_loss=0.69926357, val_CC_maskV_-1.0=0.56839567, val_MSE_maskV_-1.0=0.69653153, learning_rate=0.001\n", + "Epoch 154/165 - loss=0.62256575, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61204004, MSE_maskV_-1.0=0.62226057, val_loss=0.69791526, val_CC_maskV_-1.0=0.57034403, val_MSE_maskV_-1.0=0.69521248, learning_rate=0.001\n", + "Epoch 165/165 - loss=0.62060088, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61374754, MSE_maskV_-1.0=0.6206513, val_loss=0.69719005, val_CC_maskV_-1.0=0.57020491, val_MSE_maskV_-1.0=0.69438368, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:51:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 44.36s\n", + "\u001b[32m2025-05-30 12:51:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:51:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 90 (stopped at 105 epochs).\n", + "\u001b[32m2025-05-30 12:51:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/106 - loss=4.2462621, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.052616339, MSE_maskV_-1.0=4.2380166, val_loss=1.3363874, val_CC_maskV_-1.0=0.10526071, val_MSE_maskV_-1.0=1.3291967, learning_rate=0.001\n", + "Epoch 12/106 - loss=0.8002156, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44750908, MSE_maskV_-1.0=0.80075264, val_loss=0.86057752, val_CC_maskV_-1.0=0.42877081, val_MSE_maskV_-1.0=0.85791194, learning_rate=0.001\n", + "Epoch 23/106 - loss=0.7397055, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51050627, MSE_maskV_-1.0=0.73903, val_loss=0.81214863, val_CC_maskV_-1.0=0.47785303, val_MSE_maskV_-1.0=0.80905944, learning_rate=0.001\n", + "Epoch 34/106 - loss=0.7014249, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54623795, MSE_maskV_-1.0=0.70079046, val_loss=0.7646606, val_CC_maskV_-1.0=0.51767445, val_MSE_maskV_-1.0=0.76144576, learning_rate=0.001\n", + "Epoch 45/106 - loss=0.67001313, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57418036, MSE_maskV_-1.0=0.66953903, val_loss=0.74051893, val_CC_maskV_-1.0=0.53744376, val_MSE_maskV_-1.0=0.7375952, learning_rate=0.001\n", + "Epoch 56/106 - loss=0.65350276, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58807963, MSE_maskV_-1.0=0.65332973, val_loss=0.71752113, val_CC_maskV_-1.0=0.55481255, val_MSE_maskV_-1.0=0.71443152, learning_rate=0.001\n", + "Epoch 67/106 - loss=0.64554983, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59403557, MSE_maskV_-1.0=0.64589697, val_loss=0.71230334, val_CC_maskV_-1.0=0.55782431, val_MSE_maskV_-1.0=0.7094, learning_rate=0.001\n", + "Epoch 78/106 - loss=0.63987458, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59928465, MSE_maskV_-1.0=0.63973361, val_loss=0.71488571, val_CC_maskV_-1.0=0.56182736, val_MSE_maskV_-1.0=0.7118234, learning_rate=0.001\n", + "Epoch 89/106 - loss=0.63629967, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60189915, MSE_maskV_-1.0=0.63639903, val_loss=0.70618236, val_CC_maskV_-1.0=0.56517565, val_MSE_maskV_-1.0=0.70322335, learning_rate=0.001\n", + "Epoch 100/106 - loss=0.63183546, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60563493, MSE_maskV_-1.0=0.63213223, val_loss=0.70207173, val_CC_maskV_-1.0=0.56795222, val_MSE_maskV_-1.0=0.69912231, learning_rate=0.001\n", + "Epoch 106/106 - loss=0.63183063, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6055547, MSE_maskV_-1.0=0.63168997, val_loss=0.71604466, val_CC_maskV_-1.0=0.55951065, val_MSE_maskV_-1.0=0.71265036, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:51:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 29.10s\n", + "\u001b[32m2025-05-30 12:51:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.68919659)\n", + "\u001b[32m2025-05-30 12:51:55\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 814us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:51:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.614, R2_maskV_-1.0=0.387, CC_maskV_-1.0=0.622\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 775us/step\n", + "51/51 [==============================] - 0s 846us/step\n", + "84/84 [==============================] - 0s 709us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:51:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_CzCy1HL64U_ErSV16\" (11/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_CzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:51:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_uAKCz1HL64U_ErSV16\" (12/16)\n", + "\u001b[32m2025-05-30 12:51:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:51:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:51:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:51:57\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:51:57\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:51:57\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:51:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:52:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 118 (stopped at 133 epochs).\n", + "\u001b[32m2025-05-30 12:52:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/134 - loss=rnn_1step_loss=1.0058774, rnn_1step_R2_maskV_-1.0=-0.011303496, rnn_1step_CC_maskV_-1.0=0.035534762, rnn_1step_MSE_maskV_-1.0=1.0058773, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0906584, val_rnn_1step_R2_maskV_-1.0=-0.043513685, val_rnn_1step_CC_maskV_-1.0=0.20120814, learning_rate=0.001\n", + "Epoch 15/134 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.70662189, rnn_1step_R2_maskV_-1.0=0.28415567, rnn_1step_CC_maskV_-1.0=0.54782027, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.80435038, val_rnn_1step_R2_maskV_-1.0=0.22426465, val_rnn_1step_CC_maskV_-1.0=0.51477891, learning_rate=0.001\n", + "Epoch 29/134 - loss=rnn_1step_loss=0.57357496, rnn_1step_R2_maskV_-1.0=0.41673768, rnn_1step_CC_maskV_-1.0=0.6556524, rnn_1step_MSE_maskV_-1.0=0.5735749, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.71065331, val_rnn_1step_R2_maskV_-1.0=0.31687605, val_rnn_1step_CC_maskV_-1.0=0.58865553, learning_rate=0.001\n", + "Epoch 43/134 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.46891943, rnn_1step_R2_maskV_-1.0=0.52157927, rnn_1step_CC_maskV_-1.0=0.73044491, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61100632, val_rnn_1step_R2_maskV_-1.0=0.41510838, val_rnn_1step_CC_maskV_-1.0=0.6595524, learning_rate=0.001\n", + "Epoch 57/134 - loss=rnn_1step_loss=0.41843256, rnn_1step_R2_maskV_-1.0=0.57190233, rnn_1step_CC_maskV_-1.0=0.76423568, rnn_1step_MSE_maskV_-1.0=0.41843259, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.579557, val_rnn_1step_R2_maskV_-1.0=0.44454777, val_rnn_1step_CC_maskV_-1.0=0.68089986, learning_rate=0.001\n", + "Epoch 71/134 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37998495, rnn_1step_R2_maskV_-1.0=0.60982728, rnn_1step_CC_maskV_-1.0=0.78975344, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55193681, val_rnn_1step_R2_maskV_-1.0=0.47189537, val_rnn_1step_CC_maskV_-1.0=0.69890636, learning_rate=0.001\n", + "Epoch 85/134 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34492067, rnn_1step_R2_maskV_-1.0=0.6448437, rnn_1step_CC_maskV_-1.0=0.81091762, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53523397, val_rnn_1step_R2_maskV_-1.0=0.48796457, val_rnn_1step_CC_maskV_-1.0=0.71114153, learning_rate=0.001\n", + "Epoch 99/134 - loss=rnn_1step_loss=0.32207313, rnn_1step_R2_maskV_-1.0=0.66758728, rnn_1step_CC_maskV_-1.0=0.82476234, rnn_1step_MSE_maskV_-1.0=0.32207316, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52153951, val_rnn_1step_R2_maskV_-1.0=0.50081229, val_rnn_1step_CC_maskV_-1.0=0.71966088, learning_rate=0.001\n", + "Epoch 113/134 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30308947, rnn_1step_R2_maskV_-1.0=0.68681699, rnn_1step_CC_maskV_-1.0=0.83662373, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51293612, val_rnn_1step_R2_maskV_-1.0=0.50842094, val_rnn_1step_CC_maskV_-1.0=0.72730583, learning_rate=0.001\n", + "Epoch 127/134 - loss=rnn_1step_loss=0.280707, rnn_1step_R2_maskV_-1.0=0.71014303, rnn_1step_CC_maskV_-1.0=0.84942812, rnn_1step_MSE_maskV_-1.0=0.28070697, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51265866, val_rnn_1step_R2_maskV_-1.0=0.50886512, val_rnn_1step_CC_maskV_-1.0=0.72700107, learning_rate=0.001\n", + "Epoch 134/134 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27441069, rnn_1step_R2_maskV_-1.0=0.71656692, rnn_1step_CC_maskV_-1.0=0.85308498, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51108259, val_rnn_1step_R2_maskV_-1.0=0.51040465, val_rnn_1step_CC_maskV_-1.0=0.72814363, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:52:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 16.62s\n", + "\u001b[32m2025-05-30 12:52:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:52:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 96 (stopped at 111 epochs).\n", + "\u001b[32m2025-05-30 12:52:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/112 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0059104, rnn_1_1step_R2_maskV_-1.0=-0.011340652, rnn_1_1step_CC_maskV_-1.0=0.020693641, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0909848, val_rnn_1_1step_R2_maskV_-1.0=-0.043834656, val_rnn_1_1step_CC_maskV_-1.0=0.13420431, learning_rate=0.001\n", + "Epoch 13/112 - loss=rnn_1_1step_loss=0.73894781, rnn_1_1step_R2_maskV_-1.0=0.25231087, rnn_1_1step_CC_maskV_-1.0=0.51891756, rnn_1_1step_MSE_maskV_-1.0=0.73894775, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.82847804, val_rnn_1_1step_R2_maskV_-1.0=0.20454562, val_rnn_1_1step_CC_maskV_-1.0=0.50306261, learning_rate=0.001\n", + "Epoch 25/112 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.60344714, rnn_1_1step_R2_maskV_-1.0=0.38696724, rnn_1_1step_CC_maskV_-1.0=0.63271391, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.75460958, val_rnn_1_1step_R2_maskV_-1.0=0.26964307, val_rnn_1_1step_CC_maskV_-1.0=0.55671781, learning_rate=0.001\n", + "Epoch 37/112 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.50989443, rnn_1_1step_R2_maskV_-1.0=0.48057252, rnn_1_1step_CC_maskV_-1.0=0.70195323, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.68498635, val_rnn_1_1step_R2_maskV_-1.0=0.33871162, val_rnn_1_1step_CC_maskV_-1.0=0.60860777, learning_rate=0.001\n", + "Epoch 49/112 - loss=rnn_1_1step_loss=0.41375411, rnn_1_1step_R2_maskV_-1.0=0.57715356, rnn_1_1step_CC_maskV_-1.0=0.76718664, rnn_1_1step_MSE_maskV_-1.0=0.41375408, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56838101, val_rnn_1_1step_R2_maskV_-1.0=0.45397982, val_rnn_1_1step_CC_maskV_-1.0=0.68792719, learning_rate=0.001\n", + "Epoch 61/112 - loss=rnn_1_1step_loss=0.35503617, rnn_1_1step_R2_maskV_-1.0=0.63557684, rnn_1_1step_CC_maskV_-1.0=0.80563039, rnn_1_1step_MSE_maskV_-1.0=0.3550362, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51248509, val_rnn_1_1step_R2_maskV_-1.0=0.50851166, val_rnn_1_1step_CC_maskV_-1.0=0.72408319, learning_rate=0.001\n", + "Epoch 73/112 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31911603, rnn_1_1step_R2_maskV_-1.0=0.67282718, rnn_1_1step_CC_maskV_-1.0=0.82680875, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48936918, val_rnn_1_1step_R2_maskV_-1.0=0.53014308, val_rnn_1_1step_CC_maskV_-1.0=0.73864114, learning_rate=0.001\n", + "Epoch 85/112 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.29760358, rnn_1_1step_R2_maskV_-1.0=0.69511414, rnn_1_1step_CC_maskV_-1.0=0.84106266, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49926424, val_rnn_1_1step_R2_maskV_-1.0=0.51974416, val_rnn_1_1step_CC_maskV_-1.0=0.73315978, learning_rate=0.001\n", + "Epoch 97/112 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.27221179, rnn_1_1step_R2_maskV_-1.0=0.72155041, rnn_1_1step_CC_maskV_-1.0=0.85465008, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4998807, val_rnn_1_1step_R2_maskV_-1.0=0.5184111, val_rnn_1_1step_CC_maskV_-1.0=0.73386496, learning_rate=0.001\n", + "Epoch 109/112 - loss=rnn_1_1step_loss=0.25720719, rnn_1_1step_R2_maskV_-1.0=0.7370615, rnn_1_1step_CC_maskV_-1.0=0.86384368, rnn_1_1step_MSE_maskV_-1.0=0.25720721, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4862195, val_rnn_1_1step_R2_maskV_-1.0=0.53135681, val_rnn_1_1step_CC_maskV_-1.0=0.74283451, learning_rate=0.001\n", + "Epoch 112/112 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.25328767, rnn_1_1step_R2_maskV_-1.0=0.74087077, rnn_1_1step_CC_maskV_-1.0=0.86510324, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48554456, val_rnn_1_1step_R2_maskV_-1.0=0.53217113, val_rnn_1_1step_CC_maskV_-1.0=0.74275053, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:52:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.05s\n", + "\u001b[32m2025-05-30 12:52:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.4823235)\n", + "\u001b[32m2025-05-30 12:52:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.252, R2_maskV_-1.0=0.748, CC_maskV_-1.0=0.865\n", + "\u001b[32m2025-05-30 12:52:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.458, R2_maskV_-1.0=0.551, CC_maskV_-1.0=0.755\n", + "\u001b[32m2025-05-30 12:52:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:52:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:53:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 278 (stopped at 293 epochs).\n", + "\u001b[32m2025-05-30 12:53:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/294 - loss=1.9409926, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.027983407, MSE_maskV_-1.0=1.9397258, val_loss=1.1378057, val_CC_maskV_-1.0=0.065032825, val_MSE_maskV_-1.0=1.1307398, learning_rate=0.001\n", + "Epoch 31/294 - loss=0.87842262, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35424227, MSE_maskV_-1.0=0.87807924, val_loss=0.94602656, val_CC_maskV_-1.0=0.33211809, val_MSE_maskV_-1.0=0.9417181, learning_rate=0.001\n", + "Epoch 61/294 - loss=0.85411417, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38563076, MSE_maskV_-1.0=0.85412967, val_loss=0.92007613, val_CC_maskV_-1.0=0.36456764, val_MSE_maskV_-1.0=0.91604859, learning_rate=0.001\n", + "Epoch 91/294 - loss=0.84301478, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3989895, MSE_maskV_-1.0=0.8430891, val_loss=0.90836507, val_CC_maskV_-1.0=0.37746161, val_MSE_maskV_-1.0=0.90434247, learning_rate=0.001\n", + "Epoch 121/294 - loss=0.83538264, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40805012, MSE_maskV_-1.0=0.83598769, val_loss=0.90074629, val_CC_maskV_-1.0=0.38357174, val_MSE_maskV_-1.0=0.89714962, learning_rate=0.001\n", + "Epoch 151/294 - loss=0.83011287, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41429591, MSE_maskV_-1.0=0.82989222, val_loss=0.89613265, val_CC_maskV_-1.0=0.39024481, val_MSE_maskV_-1.0=0.89248806, learning_rate=0.001\n", + "Epoch 181/294 - loss=0.82613808, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41891059, MSE_maskV_-1.0=0.82586485, val_loss=0.88963413, val_CC_maskV_-1.0=0.39757979, val_MSE_maskV_-1.0=0.88601041, learning_rate=0.001\n", + "Epoch 211/294 - loss=0.82287544, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42254362, MSE_maskV_-1.0=0.82346809, val_loss=0.88915962, val_CC_maskV_-1.0=0.39844742, val_MSE_maskV_-1.0=0.88553673, learning_rate=0.001\n", + "Epoch 241/294 - loss=0.82009107, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42606995, MSE_maskV_-1.0=0.81969547, val_loss=0.88487232, val_CC_maskV_-1.0=0.40131354, val_MSE_maskV_-1.0=0.88121587, learning_rate=0.001\n", + "Epoch 271/294 - loss=0.81771386, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42900997, MSE_maskV_-1.0=0.81830472, val_loss=0.88052225, val_CC_maskV_-1.0=0.40719688, val_MSE_maskV_-1.0=0.87683016, learning_rate=0.001\n", + "Epoch 294/294 - loss=0.81625712, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42948076, MSE_maskV_-1.0=0.8156876, val_loss=0.88056815, val_CC_maskV_-1.0=0.406151, val_MSE_maskV_-1.0=0.8771385, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:53:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 72.45s\n", + "\u001b[32m2025-05-30 12:53:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:54:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 278 (stopped at 293 epochs).\n", + "\u001b[32m2025-05-30 12:54:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/294 - loss=1.9493542, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.041848663, MSE_maskV_-1.0=1.9479841, val_loss=1.1347789, val_CC_maskV_-1.0=0.080230713, val_MSE_maskV_-1.0=1.1278207, learning_rate=0.001\n", + "Epoch 31/294 - loss=0.87813932, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35460001, MSE_maskV_-1.0=0.87781149, val_loss=0.9443562, val_CC_maskV_-1.0=0.3345657, val_MSE_maskV_-1.0=0.94005972, learning_rate=0.001\n", + "Epoch 61/294 - loss=0.85471284, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38463441, MSE_maskV_-1.0=0.85473132, val_loss=0.92007226, val_CC_maskV_-1.0=0.36444959, val_MSE_maskV_-1.0=0.91602004, learning_rate=0.001\n", + "Epoch 91/294 - loss=0.84378672, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39783379, MSE_maskV_-1.0=0.84386599, val_loss=0.90830761, val_CC_maskV_-1.0=0.37743437, val_MSE_maskV_-1.0=0.9042502, learning_rate=0.001\n", + "Epoch 121/294 - loss=0.83614123, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40698317, MSE_maskV_-1.0=0.83674401, val_loss=0.90067983, val_CC_maskV_-1.0=0.38364175, val_MSE_maskV_-1.0=0.89704221, learning_rate=0.001\n", + "Epoch 151/294 - loss=0.8308053, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41338181, MSE_maskV_-1.0=0.83059502, val_loss=0.8959133, val_CC_maskV_-1.0=0.39048696, val_MSE_maskV_-1.0=0.89222354, learning_rate=0.001\n", + "Epoch 181/294 - loss=0.82673448, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41814655, MSE_maskV_-1.0=0.82645774, val_loss=0.8894335, val_CC_maskV_-1.0=0.39778695, val_MSE_maskV_-1.0=0.88576555, learning_rate=0.001\n", + "Epoch 211/294 - loss=0.82341391, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42183965, MSE_maskV_-1.0=0.82400477, val_loss=0.88888061, val_CC_maskV_-1.0=0.39878789, val_MSE_maskV_-1.0=0.88521224, learning_rate=0.001\n", + "Epoch 241/294 - loss=0.82055724, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42547742, MSE_maskV_-1.0=0.82016516, val_loss=0.88454926, val_CC_maskV_-1.0=0.40161005, val_MSE_maskV_-1.0=0.88085383, learning_rate=0.001\n", + "Epoch 271/294 - loss=0.81812519, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4284927, MSE_maskV_-1.0=0.8187089, val_loss=0.88028282, val_CC_maskV_-1.0=0.40747172, val_MSE_maskV_-1.0=0.87654817, learning_rate=0.001\n", + "Epoch 294/294 - loss=0.81663221, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42900166, MSE_maskV_-1.0=0.81605428, val_loss=0.88024044, val_CC_maskV_-1.0=0.4065055, val_MSE_maskV_-1.0=0.8767668, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:54:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 72.91s\n", + "\u001b[32m2025-05-30 12:54:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.87927967)\n", + "\u001b[32m2025-05-30 12:54:55\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 799us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:54:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.817, R2_maskV_-1.0=0.182, CC_maskV_-1.0=0.429\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 796us/step\n", + "51/51 [==============================] - 0s 728us/step\n", + "84/84 [==============================] - 0s 684us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:54:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_uAKCz1HL64U_ErSV16\" (12/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_uAKCz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:54:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_uAKCy1HL64U_ErSV16\" (13/16)\n", + "\u001b[32m2025-05-30 12:54:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:54:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:54:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:54:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:54:56\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:54:56\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:54:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:55:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 78 (stopped at 93 epochs).\n", + "\u001b[32m2025-05-30 12:55:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/94 - loss=rnn_1step_loss=1.0058689, rnn_1step_R2_maskV_-1.0=-0.011275444, rnn_1step_CC_maskV_-1.0=0.019172734, rnn_1step_MSE_maskV_-1.0=1.0058688, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0893937, val_rnn_1step_R2_maskV_-1.0=-0.042269677, val_rnn_1step_CC_maskV_-1.0=0.23918195, learning_rate=0.001\n", + "Epoch 11/94 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.86407518, rnn_1step_R2_maskV_-1.0=0.13289824, rnn_1step_CC_maskV_-1.0=0.43190861, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91263175, val_rnn_1step_R2_maskV_-1.0=0.1270843, val_rnn_1step_CC_maskV_-1.0=0.44293603, learning_rate=0.001\n", + "Epoch 21/94 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.58760124, rnn_1step_R2_maskV_-1.0=0.40279472, rnn_1step_CC_maskV_-1.0=0.64695013, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.72332889, val_rnn_1step_R2_maskV_-1.0=0.30306137, val_rnn_1step_CC_maskV_-1.0=0.59653473, learning_rate=0.001\n", + "Epoch 31/94 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.47295609, rnn_1step_R2_maskV_-1.0=0.51716959, rnn_1step_CC_maskV_-1.0=0.72764862, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61052984, val_rnn_1step_R2_maskV_-1.0=0.4133696, val_rnn_1step_CC_maskV_-1.0=0.66641492, learning_rate=0.001\n", + "Epoch 41/94 - loss=rnn_1step_loss=0.39839172, rnn_1step_R2_maskV_-1.0=0.59212744, rnn_1step_CC_maskV_-1.0=0.77697378, rnn_1step_MSE_maskV_-1.0=0.39839169, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53900522, val_rnn_1step_R2_maskV_-1.0=0.48296177, val_rnn_1step_CC_maskV_-1.0=0.7108174, learning_rate=0.001\n", + "Epoch 51/94 - loss=rnn_1step_loss=0.33579603, rnn_1step_R2_maskV_-1.0=0.65607041, rnn_1step_CC_maskV_-1.0=0.81642962, rnn_1step_MSE_maskV_-1.0=0.33579606, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49622288, val_rnn_1step_R2_maskV_-1.0=0.52290481, val_rnn_1step_CC_maskV_-1.0=0.73605317, learning_rate=0.001\n", + "Epoch 61/94 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29385319, rnn_1step_R2_maskV_-1.0=0.69945312, rnn_1step_CC_maskV_-1.0=0.84180343, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46281591, val_rnn_1step_R2_maskV_-1.0=0.5540641, val_rnn_1step_CC_maskV_-1.0=0.75633931, learning_rate=0.001\n", + "Epoch 71/94 - loss=rnn_1step_loss=0.27998975, rnn_1step_R2_maskV_-1.0=0.71224606, rnn_1step_CC_maskV_-1.0=0.85030937, rnn_1step_MSE_maskV_-1.0=0.27998978, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46753541, val_rnn_1step_R2_maskV_-1.0=0.54947227, val_rnn_1step_CC_maskV_-1.0=0.75573349, learning_rate=0.001\n", + "Epoch 81/94 - loss=rnn_1step_loss=0.24684231, rnn_1step_R2_maskV_-1.0=0.74722588, rnn_1step_CC_maskV_-1.0=0.86919653, rnn_1step_MSE_maskV_-1.0=0.24684232, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4482967, val_rnn_1step_R2_maskV_-1.0=0.56784523, val_rnn_1step_CC_maskV_-1.0=0.76632786, learning_rate=0.001\n", + "Epoch 91/94 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.24000569, rnn_1step_R2_maskV_-1.0=0.75447536, rnn_1step_CC_maskV_-1.0=0.87305093, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45449963, val_rnn_1step_R2_maskV_-1.0=0.56213808, val_rnn_1step_CC_maskV_-1.0=0.7634387, learning_rate=0.001\n", + "Epoch 94/94 - loss=rnn_1step_loss=0.23198454, rnn_1step_R2_maskV_-1.0=0.76237333, rnn_1step_CC_maskV_-1.0=0.87755597, rnn_1step_MSE_maskV_-1.0=0.23198453, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4555172, val_rnn_1step_R2_maskV_-1.0=0.56197006, val_rnn_1step_CC_maskV_-1.0=0.76373219, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:55:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.09s\n", + "\u001b[32m2025-05-30 12:55:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:55:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 87 (stopped at 102 epochs).\n", + "\u001b[32m2025-05-30 12:55:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/103 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0059319, rnn_1_1step_R2_maskV_-1.0=-0.011334825, rnn_1_1step_CC_maskV_-1.0=0.0036831871, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0890155, val_rnn_1_1step_R2_maskV_-1.0=-0.041964352, val_rnn_1_1step_CC_maskV_-1.0=0.25858653, learning_rate=0.001\n", + "Epoch 12/103 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.82431954, rnn_1_1step_R2_maskV_-1.0=0.16704461, rnn_1_1step_CC_maskV_-1.0=0.4287619, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.89088368, val_rnn_1_1step_R2_maskV_-1.0=0.14153312, val_rnn_1_1step_CC_maskV_-1.0=0.43142775, learning_rate=0.001\n", + "Epoch 23/103 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.58762425, rnn_1_1step_R2_maskV_-1.0=0.40183198, rnn_1_1step_CC_maskV_-1.0=0.64502722, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.70929402, val_rnn_1_1step_R2_maskV_-1.0=0.3129485, val_rnn_1_1step_CC_maskV_-1.0=0.60031438, learning_rate=0.001\n", + "Epoch 34/103 - loss=rnn_1_1step_loss=0.49881694, rnn_1_1step_R2_maskV_-1.0=0.4897182, rnn_1_1step_CC_maskV_-1.0=0.70990682, rnn_1_1step_MSE_maskV_-1.0=0.49881691, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63363189, val_rnn_1_1step_R2_maskV_-1.0=0.3880187, val_rnn_1_1step_CC_maskV_-1.0=0.65130198, learning_rate=0.001\n", + "Epoch 45/103 - loss=rnn_1_1step_loss=0.42789093, rnn_1_1step_R2_maskV_-1.0=0.56201071, rnn_1_1step_CC_maskV_-1.0=0.75762939, rnn_1_1step_MSE_maskV_-1.0=0.42789096, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56275028, val_rnn_1_1step_R2_maskV_-1.0=0.45907247, val_rnn_1_1step_CC_maskV_-1.0=0.69337696, learning_rate=0.001\n", + "Epoch 56/103 - loss=rnn_1_1step_loss=0.37438187, rnn_1_1step_R2_maskV_-1.0=0.61735386, rnn_1_1step_CC_maskV_-1.0=0.79199737, rnn_1_1step_MSE_maskV_-1.0=0.37438184, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51241392, val_rnn_1_1step_R2_maskV_-1.0=0.50820166, val_rnn_1_1step_CC_maskV_-1.0=0.72398198, learning_rate=0.001\n", + "Epoch 67/103 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33309293, rnn_1_1step_R2_maskV_-1.0=0.65879405, rnn_1_1step_CC_maskV_-1.0=0.81781179, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47326025, val_rnn_1_1step_R2_maskV_-1.0=0.5452652, val_rnn_1_1step_CC_maskV_-1.0=0.74959004, learning_rate=0.001\n", + "Epoch 78/103 - loss=rnn_1_1step_loss=0.30798483, rnn_1_1step_R2_maskV_-1.0=0.68439865, rnn_1_1step_CC_maskV_-1.0=0.83287156, rnn_1_1step_MSE_maskV_-1.0=0.30798486, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46458378, val_rnn_1_1step_R2_maskV_-1.0=0.55367917, val_rnn_1_1step_CC_maskV_-1.0=0.75400251, learning_rate=0.001\n", + "Epoch 89/103 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.28853056, rnn_1_1step_R2_maskV_-1.0=0.70416284, rnn_1_1step_CC_maskV_-1.0=0.84463435, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45861304, val_rnn_1_1step_R2_maskV_-1.0=0.55906439, val_rnn_1_1step_CC_maskV_-1.0=0.75913978, learning_rate=0.001\n", + "Epoch 100/103 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.27007413, rnn_1_1step_R2_maskV_-1.0=0.72334015, rnn_1_1step_CC_maskV_-1.0=0.8552177, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46229997, val_rnn_1_1step_R2_maskV_-1.0=0.55560726, val_rnn_1_1step_CC_maskV_-1.0=0.75757855, learning_rate=0.001\n", + "Epoch 103/103 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.26549554, rnn_1_1step_R2_maskV_-1.0=0.72802836, rnn_1_1step_CC_maskV_-1.0=0.85801923, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47130886, val_rnn_1_1step_R2_maskV_-1.0=0.54707795, val_rnn_1_1step_CC_maskV_-1.0=0.75173748, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:55:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 13.22s\n", + "\u001b[32m2025-05-30 12:55:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.44422522)\n", + "\u001b[32m2025-05-30 12:55:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.228, R2_maskV_-1.0=0.773, CC_maskV_-1.0=0.879\n", + "\u001b[32m2025-05-30 12:55:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.429, R2_maskV_-1.0=0.577, CC_maskV_-1.0=0.773\n", + "\u001b[32m2025-05-30 12:55:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:55:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:56:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 244 (stopped at 259 epochs).\n", + "\u001b[32m2025-05-30 12:56:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/260 - loss=1.018887, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.15967104, MSE_maskV_-1.0=1.0200595, val_loss=1.0081768, val_CC_maskV_-1.0=0.22391511, val_MSE_maskV_-1.0=1.0031444, learning_rate=0.001\n", + "Epoch 27/260 - loss=0.79659104, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45120859, MSE_maskV_-1.0=0.79692262, val_loss=0.87024218, val_CC_maskV_-1.0=0.40900359, val_MSE_maskV_-1.0=0.8666296, learning_rate=0.001\n", + "Epoch 53/260 - loss=0.77070057, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47854838, MSE_maskV_-1.0=0.77048302, val_loss=0.85068655, val_CC_maskV_-1.0=0.42796463, val_MSE_maskV_-1.0=0.84722948, learning_rate=0.001\n", + "Epoch 79/260 - loss=0.7544207, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49436304, MSE_maskV_-1.0=0.75458813, val_loss=0.83799428, val_CC_maskV_-1.0=0.44284943, val_MSE_maskV_-1.0=0.83451962, learning_rate=0.001\n", + "Epoch 105/260 - loss=0.74408448, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50479728, MSE_maskV_-1.0=0.74382818, val_loss=0.82947552, val_CC_maskV_-1.0=0.44887963, val_MSE_maskV_-1.0=0.82645035, learning_rate=0.001\n", + "Epoch 131/260 - loss=0.73571312, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51252949, MSE_maskV_-1.0=0.73520404, val_loss=0.82578665, val_CC_maskV_-1.0=0.45270741, val_MSE_maskV_-1.0=0.82291979, learning_rate=0.001\n", + "Epoch 157/260 - loss=0.73009723, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51839322, MSE_maskV_-1.0=0.72945589, val_loss=0.81545222, val_CC_maskV_-1.0=0.46041474, val_MSE_maskV_-1.0=0.81264883, learning_rate=0.001\n", + "Epoch 183/260 - loss=0.72465849, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5234322, MSE_maskV_-1.0=0.72495502, val_loss=0.81025326, val_CC_maskV_-1.0=0.4642708, val_MSE_maskV_-1.0=0.80759507, learning_rate=0.001\n", + "Epoch 209/260 - loss=0.72104567, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52782851, MSE_maskV_-1.0=0.72165716, val_loss=0.80942589, val_CC_maskV_-1.0=0.46621862, val_MSE_maskV_-1.0=0.80653405, learning_rate=0.001\n", + "Epoch 235/260 - loss=0.71841913, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52947176, MSE_maskV_-1.0=0.71824861, val_loss=0.80978823, val_CC_maskV_-1.0=0.46591526, val_MSE_maskV_-1.0=0.80698389, learning_rate=0.001\n", + "Epoch 260/260 - loss=0.71536821, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53261971, MSE_maskV_-1.0=0.71580571, val_loss=0.80535829, val_CC_maskV_-1.0=0.4694854, val_MSE_maskV_-1.0=0.80246079, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:56:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 69.23s\n", + "\u001b[32m2025-05-30 12:56:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:57:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 133 (stopped at 148 epochs).\n", + "\u001b[32m2025-05-30 12:57:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/149 - loss=1.0101811, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.16859855, MSE_maskV_-1.0=1.0112102, val_loss=1.0029297, val_CC_maskV_-1.0=0.23277731, val_MSE_maskV_-1.0=0.99831086, learning_rate=0.001\n", + "Epoch 16/149 - loss=0.81976801, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42557973, MSE_maskV_-1.0=0.81983846, val_loss=0.89760685, val_CC_maskV_-1.0=0.38385093, val_MSE_maskV_-1.0=0.89421618, learning_rate=0.001\n", + "Epoch 31/149 - loss=0.79168314, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45759255, MSE_maskV_-1.0=0.79128021, val_loss=0.87388521, val_CC_maskV_-1.0=0.40519509, val_MSE_maskV_-1.0=0.87033266, learning_rate=0.001\n", + "Epoch 46/149 - loss=0.77552015, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47291949, MSE_maskV_-1.0=0.77597082, val_loss=0.85814059, val_CC_maskV_-1.0=0.42236945, val_MSE_maskV_-1.0=0.85449797, learning_rate=0.001\n", + "Epoch 61/149 - loss=0.76379484, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48553884, MSE_maskV_-1.0=0.76370496, val_loss=0.84755212, val_CC_maskV_-1.0=0.4315643, val_MSE_maskV_-1.0=0.84418988, learning_rate=0.001\n", + "Epoch 76/149 - loss=0.75613588, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49340996, MSE_maskV_-1.0=0.75648212, val_loss=0.8379783, val_CC_maskV_-1.0=0.44098008, val_MSE_maskV_-1.0=0.83478928, learning_rate=0.001\n", + "Epoch 91/149 - loss=0.74930406, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50024229, MSE_maskV_-1.0=0.74932057, val_loss=0.83513302, val_CC_maskV_-1.0=0.44441563, val_MSE_maskV_-1.0=0.83186615, learning_rate=0.001\n", + "Epoch 106/149 - loss=0.74347049, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5055728, MSE_maskV_-1.0=0.74329299, val_loss=0.83198088, val_CC_maskV_-1.0=0.44802341, val_MSE_maskV_-1.0=0.82863408, learning_rate=0.001\n", + "Epoch 121/149 - loss=0.73826599, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51134735, MSE_maskV_-1.0=0.73864943, val_loss=0.8283444, val_CC_maskV_-1.0=0.45019403, val_MSE_maskV_-1.0=0.82502306, learning_rate=0.001\n", + "Epoch 136/149 - loss=0.73427236, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51496363, MSE_maskV_-1.0=0.73405391, val_loss=0.82142627, val_CC_maskV_-1.0=0.45578682, val_MSE_maskV_-1.0=0.81812513, learning_rate=0.001\n", + "Epoch 149/149 - loss=0.73102391, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51850998, MSE_maskV_-1.0=0.73103493, val_loss=0.82182842, val_CC_maskV_-1.0=0.4565267, val_MSE_maskV_-1.0=0.81855911, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:57:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 40.08s\n", + "\u001b[32m2025-05-30 12:57:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.80514336)\n", + "\u001b[32m2025-05-30 12:57:12\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 823us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:57:13\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.714, R2_maskV_-1.0=0.287, CC_maskV_-1.0=0.536\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 799us/step\n", + "51/51 [==============================] - 0s 798us/step\n", + "84/84 [==============================] - 0s 769us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:57:14\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_uAKCy1HL64U_ErSV16\" (13/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_uAKCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:57:14\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_ACzCy1HL64U_ErSV16\" (14/16)\n", + "\u001b[32m2025-05-30 12:57:14\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:57:14\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:57:14\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:57:14\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:57:14\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:57:14\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:57:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:57:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 132 (stopped at 147 epochs).\n", + "\u001b[32m2025-05-30 12:57:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/148 - loss=rnn_1step_loss=1.0049757, rnn_1step_R2_maskV_-1.0=-0.010385707, rnn_1step_CC_maskV_-1.0=0.10663965, rnn_1step_MSE_maskV_-1.0=1.0049756, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0883226, val_rnn_1step_R2_maskV_-1.0=-0.041215122, val_rnn_1step_CC_maskV_-1.0=0.2276645, learning_rate=0.001\n", + "Epoch 16/148 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.7845664, rnn_1step_R2_maskV_-1.0=0.20431806, rnn_1step_CC_maskV_-1.0=0.46821159, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.87531328, val_rnn_1step_R2_maskV_-1.0=0.16372347, val_rnn_1step_CC_maskV_-1.0=0.44741124, learning_rate=0.001\n", + "Epoch 31/148 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.56761056, rnn_1step_R2_maskV_-1.0=0.4236064, rnn_1step_CC_maskV_-1.0=0.65872413, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.66706485, val_rnn_1step_R2_maskV_-1.0=0.35979524, val_rnn_1step_CC_maskV_-1.0=0.61973685, learning_rate=0.001\n", + "Epoch 46/148 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.47093856, rnn_1step_R2_maskV_-1.0=0.51989633, rnn_1step_CC_maskV_-1.0=0.72852212, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54806799, val_rnn_1step_R2_maskV_-1.0=0.47643858, val_rnn_1step_CC_maskV_-1.0=0.70380294, learning_rate=0.001\n", + "Epoch 61/148 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42533466, rnn_1step_R2_maskV_-1.0=0.56483996, rnn_1step_CC_maskV_-1.0=0.75944817, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49716544, val_rnn_1step_R2_maskV_-1.0=0.52629304, val_rnn_1step_CC_maskV_-1.0=0.73540944, learning_rate=0.001\n", + "Epoch 76/148 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39652023, rnn_1step_R2_maskV_-1.0=0.59392875, rnn_1step_CC_maskV_-1.0=0.77812439, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47070125, val_rnn_1step_R2_maskV_-1.0=0.55115783, val_rnn_1step_CC_maskV_-1.0=0.75184852, learning_rate=0.001\n", + "Epoch 91/148 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37274122, rnn_1step_R2_maskV_-1.0=0.61833656, rnn_1step_CC_maskV_-1.0=0.79338408, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45358267, val_rnn_1step_R2_maskV_-1.0=0.56694341, val_rnn_1step_CC_maskV_-1.0=0.76258641, learning_rate=0.001\n", + "Epoch 106/148 - loss=rnn_1step_loss=0.35252318, rnn_1step_R2_maskV_-1.0=0.63904184, rnn_1step_CC_maskV_-1.0=0.80617636, rnn_1step_MSE_maskV_-1.0=0.35252312, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44091502, val_rnn_1step_R2_maskV_-1.0=0.57819605, val_rnn_1step_CC_maskV_-1.0=0.77046603, learning_rate=0.001\n", + "Epoch 121/148 - loss=rnn_1step_loss=0.33393297, rnn_1step_R2_maskV_-1.0=0.65805757, rnn_1step_CC_maskV_-1.0=0.81789154, rnn_1step_MSE_maskV_-1.0=0.33393294, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44101104, val_rnn_1step_R2_maskV_-1.0=0.57691401, val_rnn_1step_CC_maskV_-1.0=0.77066648, learning_rate=0.001\n", + "Epoch 136/148 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32031748, rnn_1step_R2_maskV_-1.0=0.67177361, rnn_1step_CC_maskV_-1.0=0.82682377, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44610476, val_rnn_1step_R2_maskV_-1.0=0.57111269, val_rnn_1step_CC_maskV_-1.0=0.76571089, learning_rate=0.001\n", + "Epoch 148/148 - loss=rnn_1step_loss=0.30582055, rnn_1step_R2_maskV_-1.0=0.68675125, rnn_1step_CC_maskV_-1.0=0.83442342, rnn_1step_MSE_maskV_-1.0=0.30582058, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4254812, val_rnn_1step_R2_maskV_-1.0=0.59070891, val_rnn_1step_CC_maskV_-1.0=0.78119928, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:57:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 17.72s\n", + "\u001b[32m2025-05-30 12:57:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:57:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 147 (stopped at 162 epochs).\n", + "\u001b[32m2025-05-30 12:57:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/163 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0055872, rnn_1_1step_R2_maskV_-1.0=-0.010997336, rnn_1_1step_CC_maskV_-1.0=0.053526022, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0890406, val_rnn_1_1step_R2_maskV_-1.0=-0.041981533, val_rnn_1_1step_CC_maskV_-1.0=0.26028362, learning_rate=0.001\n", + "Epoch 18/163 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.68736291, rnn_1_1step_R2_maskV_-1.0=0.30417097, rnn_1_1step_CC_maskV_-1.0=0.5648759, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.73897028, val_rnn_1_1step_R2_maskV_-1.0=0.29034325, val_rnn_1_1step_CC_maskV_-1.0=0.56591958, learning_rate=0.001\n", + "Epoch 35/163 - loss=rnn_1_1step_loss=0.46416894, rnn_1_1step_R2_maskV_-1.0=0.5281834, rnn_1_1step_CC_maskV_-1.0=0.73338217, rnn_1_1step_MSE_maskV_-1.0=0.46416897, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5254131, val_rnn_1_1step_R2_maskV_-1.0=0.49435824, val_rnn_1_1step_CC_maskV_-1.0=0.71708137, learning_rate=0.001\n", + "Epoch 52/163 - loss=rnn_1_1step_loss=0.41309944, rnn_1_1step_R2_maskV_-1.0=0.57922059, rnn_1_1step_CC_maskV_-1.0=0.76773661, rnn_1_1step_MSE_maskV_-1.0=0.41309947, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48330966, val_rnn_1_1step_R2_maskV_-1.0=0.5355013, val_rnn_1_1step_CC_maskV_-1.0=0.74460125, learning_rate=0.001\n", + "Epoch 69/163 - loss=rnn_1_1step_loss=0.38138911, rnn_1_1step_R2_maskV_-1.0=0.611233, rnn_1_1step_CC_maskV_-1.0=0.78803146, rnn_1_1step_MSE_maskV_-1.0=0.38138908, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46326903, val_rnn_1_1step_R2_maskV_-1.0=0.555834, val_rnn_1_1step_CC_maskV_-1.0=0.75595927, learning_rate=0.001\n", + "Epoch 86/163 - loss=rnn_1_1step_loss=0.35544467, rnn_1_1step_R2_maskV_-1.0=0.63752699, rnn_1_1step_CC_maskV_-1.0=0.8040989, rnn_1_1step_MSE_maskV_-1.0=0.3554447, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.44863674, val_rnn_1_1step_R2_maskV_-1.0=0.56989819, val_rnn_1_1step_CC_maskV_-1.0=0.76431823, learning_rate=0.001\n", + "Epoch 103/163 - loss=rnn_1_1step_loss=0.33883366, rnn_1_1step_R2_maskV_-1.0=0.65391302, rnn_1_1step_CC_maskV_-1.0=0.81482583, rnn_1_1step_MSE_maskV_-1.0=0.33883363, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.43005666, val_rnn_1_1step_R2_maskV_-1.0=0.5878337, val_rnn_1_1step_CC_maskV_-1.0=0.77882802, learning_rate=0.001\n", + "Epoch 120/163 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.3267487, rnn_1_1step_R2_maskV_-1.0=0.66627336, rnn_1_1step_CC_maskV_-1.0=0.82276618, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.42652178, val_rnn_1_1step_R2_maskV_-1.0=0.5905934, val_rnn_1_1step_CC_maskV_-1.0=0.78146499, learning_rate=0.001\n", + "Epoch 137/163 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32026291, rnn_1_1step_R2_maskV_-1.0=0.67229557, rnn_1_1step_CC_maskV_-1.0=0.82749993, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.42439935, val_rnn_1_1step_R2_maskV_-1.0=0.59330571, val_rnn_1_1step_CC_maskV_-1.0=0.78138989, learning_rate=0.001\n", + "Epoch 154/163 - loss=rnn_1_1step_loss=0.31048071, rnn_1_1step_R2_maskV_-1.0=0.68257535, rnn_1_1step_CC_maskV_-1.0=0.83223617, rnn_1_1step_MSE_maskV_-1.0=0.31048074, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4179568, val_rnn_1_1step_R2_maskV_-1.0=0.59895402, val_rnn_1_1step_CC_maskV_-1.0=0.7820009, learning_rate=0.001\n", + "Epoch 163/163 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.3040075, rnn_1_1step_R2_maskV_-1.0=0.68904328, rnn_1_1step_CC_maskV_-1.0=0.8359822, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41381073, val_rnn_1_1step_R2_maskV_-1.0=0.60364652, val_rnn_1_1step_CC_maskV_-1.0=0.78949308, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:57:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 19.31s\n", + "\u001b[32m2025-05-30 12:57:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.4044036)\n", + "\u001b[32m2025-05-30 12:57:53\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.282, R2_maskV_-1.0=0.718, CC_maskV_-1.0=0.848\n", + "\u001b[32m2025-05-30 12:57:53\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.39, R2_maskV_-1.0=0.618, CC_maskV_-1.0=0.796\n", + "\u001b[32m2025-05-30 12:57:53\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 12:57:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:58:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 156 (stopped at 171 epochs).\n", + "\u001b[32m2025-05-30 12:58:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/172 - loss=1.7854337, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.10738845, MSE_maskV_-1.0=1.7843291, val_loss=1.0569404, val_CC_maskV_-1.0=0.19819297, val_MSE_maskV_-1.0=1.0520191, learning_rate=0.001\n", + "Epoch 19/172 - loss=0.70818359, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53963047, MSE_maskV_-1.0=0.70813853, val_loss=0.77816224, val_CC_maskV_-1.0=0.5059759, val_MSE_maskV_-1.0=0.77565747, learning_rate=0.001\n", + "Epoch 37/172 - loss=0.66937399, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57449847, MSE_maskV_-1.0=0.66945487, val_loss=0.73799568, val_CC_maskV_-1.0=0.53796905, val_MSE_maskV_-1.0=0.73560458, learning_rate=0.001\n", + "Epoch 55/172 - loss=0.64908195, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59178901, MSE_maskV_-1.0=0.64968902, val_loss=0.71855861, val_CC_maskV_-1.0=0.55348855, val_MSE_maskV_-1.0=0.71636796, learning_rate=0.001\n", + "Epoch 73/172 - loss=0.63960654, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59949291, MSE_maskV_-1.0=0.63937908, val_loss=0.71263903, val_CC_maskV_-1.0=0.56008607, val_MSE_maskV_-1.0=0.70991498, learning_rate=0.001\n", + "Epoch 91/172 - loss=0.633259, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60453725, MSE_maskV_-1.0=0.6330263, val_loss=0.7061047, val_CC_maskV_-1.0=0.56637597, val_MSE_maskV_-1.0=0.70268434, learning_rate=0.001\n", + "Epoch 109/172 - loss=0.62945789, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60763961, MSE_maskV_-1.0=0.62913746, val_loss=0.70362073, val_CC_maskV_-1.0=0.56861228, val_MSE_maskV_-1.0=0.70090979, learning_rate=0.001\n", + "Epoch 127/172 - loss=0.62456602, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61197019, MSE_maskV_-1.0=0.62441689, val_loss=0.70239747, val_CC_maskV_-1.0=0.56943053, val_MSE_maskV_-1.0=0.69929737, learning_rate=0.001\n", + "Epoch 145/172 - loss=0.62217587, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6136508, MSE_maskV_-1.0=0.62216538, val_loss=0.700755, val_CC_maskV_-1.0=0.57056916, val_MSE_maskV_-1.0=0.69763982, learning_rate=0.001\n", + "Epoch 163/172 - loss=0.61909902, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61646414, MSE_maskV_-1.0=0.61893702, val_loss=0.69991463, val_CC_maskV_-1.0=0.5711686, val_MSE_maskV_-1.0=0.69673306, learning_rate=0.001\n", + "Epoch 172/172 - loss=0.61733544, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61724222, MSE_maskV_-1.0=0.6172601, val_loss=0.70102406, val_CC_maskV_-1.0=0.57113862, val_MSE_maskV_-1.0=0.69763458, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:58:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 45.48s\n", + "\u001b[32m2025-05-30 12:58:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:59:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 132 (stopped at 147 epochs).\n", + "\u001b[32m2025-05-30 12:59:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/148 - loss=1.5127774, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.10934523, MSE_maskV_-1.0=1.5125234, val_loss=1.0509533, val_CC_maskV_-1.0=0.19716689, val_MSE_maskV_-1.0=1.0455019, learning_rate=0.001\n", + "Epoch 16/148 - loss=0.71708125, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53166616, MSE_maskV_-1.0=0.71714449, val_loss=0.78813249, val_CC_maskV_-1.0=0.49951211, val_MSE_maskV_-1.0=0.78453916, learning_rate=0.001\n", + "Epoch 31/148 - loss=0.67823124, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5674091, MSE_maskV_-1.0=0.67783904, val_loss=0.75004107, val_CC_maskV_-1.0=0.53340137, val_MSE_maskV_-1.0=0.74618685, learning_rate=0.001\n", + "Epoch 46/148 - loss=0.65840995, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5839262, MSE_maskV_-1.0=0.65869749, val_loss=0.72825664, val_CC_maskV_-1.0=0.55122602, val_MSE_maskV_-1.0=0.72431856, learning_rate=0.001\n", + "Epoch 61/148 - loss=0.64635801, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59320962, MSE_maskV_-1.0=0.64662677, val_loss=0.71516711, val_CC_maskV_-1.0=0.55814177, val_MSE_maskV_-1.0=0.7114771, learning_rate=0.001\n", + "Epoch 76/148 - loss=0.63919997, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59946257, MSE_maskV_-1.0=0.63949311, val_loss=0.705244, val_CC_maskV_-1.0=0.5662322, val_MSE_maskV_-1.0=0.70178711, learning_rate=0.001\n", + "Epoch 91/148 - loss=0.63400978, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6040749, MSE_maskV_-1.0=0.63379389, val_loss=0.70264834, val_CC_maskV_-1.0=0.5686639, val_MSE_maskV_-1.0=0.69873744, learning_rate=0.001\n", + "Epoch 106/148 - loss=0.62909108, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60812426, MSE_maskV_-1.0=0.6288777, val_loss=0.70331436, val_CC_maskV_-1.0=0.56776142, val_MSE_maskV_-1.0=0.69984704, learning_rate=0.001\n", + "Epoch 121/148 - loss=0.62470645, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6119287, MSE_maskV_-1.0=0.62520558, val_loss=0.69797379, val_CC_maskV_-1.0=0.57161468, val_MSE_maskV_-1.0=0.69460595, learning_rate=0.001\n", + "Epoch 136/148 - loss=0.62200403, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6139974, MSE_maskV_-1.0=0.62187696, val_loss=0.6950599, val_CC_maskV_-1.0=0.573852, val_MSE_maskV_-1.0=0.69155496, learning_rate=0.001\n", + "Epoch 148/148 - loss=0.62063694, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6150046, MSE_maskV_-1.0=0.62013018, val_loss=0.69690651, val_CC_maskV_-1.0=0.57135314, val_MSE_maskV_-1.0=0.69370157, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:59:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 39.85s\n", + "\u001b[32m2025-05-30 12:59:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.69283837)\n", + "\u001b[32m2025-05-30 12:59:18\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 817us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:59:18\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.62, R2_maskV_-1.0=0.379, CC_maskV_-1.0=0.617\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 751us/step\n", + "51/51 [==============================] - 0s 834us/step\n", + "84/84 [==============================] - 0s 754us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 12:59:19\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_ACzCy1HL64U_ErSV16\" (14/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_ACzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 12:59:19\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_KCzCy1HL64U_ErSV16\" (15/16)\n", + "\u001b[32m2025-05-30 12:59:19\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 12:59:19\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 12:59:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 12:59:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 12:59:20\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 12:59:20\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 12:59:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 12:59:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 167 (stopped at 182 epochs).\n", + "\u001b[32m2025-05-30 12:59:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/183 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0058012, rnn_1step_R2_maskV_-1.0=-0.011228587, rnn_1step_CC_maskV_-1.0=0.06263338, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0904764, val_rnn_1step_R2_maskV_-1.0=-0.04335098, val_rnn_1step_CC_maskV_-1.0=0.25474295, learning_rate=0.001\n", + "Epoch 20/183 - loss=rnn_1step_loss=0.63454109, rnn_1step_R2_maskV_-1.0=0.35624492, rnn_1step_CC_maskV_-1.0=0.60797155, rnn_1step_MSE_maskV_-1.0=0.63454103, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.76621199, val_rnn_1step_R2_maskV_-1.0=0.25934494, val_rnn_1step_CC_maskV_-1.0=0.55708283, learning_rate=0.001\n", + "Epoch 39/183 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.44724962, rnn_1step_R2_maskV_-1.0=0.54402995, rnn_1step_CC_maskV_-1.0=0.74543202, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55736798, val_rnn_1step_R2_maskV_-1.0=0.46606266, val_rnn_1step_CC_maskV_-1.0=0.69500142, learning_rate=0.001\n", + "Epoch 58/183 - loss=rnn_1step_loss=0.34761572, rnn_1step_R2_maskV_-1.0=0.64433777, rnn_1step_CC_maskV_-1.0=0.8094604, rnn_1step_MSE_maskV_-1.0=0.34761575, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45668206, val_rnn_1step_R2_maskV_-1.0=0.56307906, val_rnn_1step_CC_maskV_-1.0=0.75870627, learning_rate=0.001\n", + "Epoch 77/183 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30274093, rnn_1step_R2_maskV_-1.0=0.69055498, rnn_1step_CC_maskV_-1.0=0.83637083, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.43109703, val_rnn_1step_R2_maskV_-1.0=0.5882706, val_rnn_1step_CC_maskV_-1.0=0.77440161, learning_rate=0.001\n", + "Epoch 96/183 - loss=rnn_1step_loss=0.26604763, rnn_1step_R2_maskV_-1.0=0.72833985, rnn_1step_CC_maskV_-1.0=0.85778135, rnn_1step_MSE_maskV_-1.0=0.2660476, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42084411, val_rnn_1step_R2_maskV_-1.0=0.59813023, val_rnn_1step_CC_maskV_-1.0=0.7808001, learning_rate=0.001\n", + "Epoch 115/183 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.23238194, rnn_1step_R2_maskV_-1.0=0.76278174, rnn_1step_CC_maskV_-1.0=0.8773666, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.40827394, val_rnn_1step_R2_maskV_-1.0=0.61005652, val_rnn_1step_CC_maskV_-1.0=0.78853261, learning_rate=0.001\n", + "Epoch 134/183 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.20900129, rnn_1step_R2_maskV_-1.0=0.78640759, rnn_1step_CC_maskV_-1.0=0.89037997, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.39497271, val_rnn_1step_R2_maskV_-1.0=0.62307554, val_rnn_1step_CC_maskV_-1.0=0.7980727, learning_rate=0.001\n", + "Epoch 153/183 - loss=rnn_1step_loss=0.19518255, rnn_1step_R2_maskV_-1.0=0.79992986, rnn_1step_CC_maskV_-1.0=0.89807922, rnn_1step_MSE_maskV_-1.0=0.19518253, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.38980135, val_rnn_1step_R2_maskV_-1.0=0.62736207, val_rnn_1step_CC_maskV_-1.0=0.8004657, learning_rate=0.001\n", + "Epoch 172/183 - loss=rnn_1step_loss=0.18523002, rnn_1step_R2_maskV_-1.0=0.81045932, rnn_1step_CC_maskV_-1.0=0.9037019, rnn_1step_MSE_maskV_-1.0=0.18523003, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.39014745, val_rnn_1step_R2_maskV_-1.0=0.62669146, val_rnn_1step_CC_maskV_-1.0=0.80097318, learning_rate=0.001\n", + "Epoch 183/183 - loss=rnn_1step_loss=0.18041235, rnn_1step_R2_maskV_-1.0=0.81535655, rnn_1step_CC_maskV_-1.0=0.90624261, rnn_1step_MSE_maskV_-1.0=0.18041234, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.38477948, val_rnn_1step_R2_maskV_-1.0=0.63194537, val_rnn_1step_CC_maskV_-1.0=0.80351794, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:59:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 20.19s\n", + "\u001b[32m2025-05-30 12:59:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 12:59:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 142 (stopped at 157 epochs).\n", + "\u001b[32m2025-05-30 12:59:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/158 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.005829, rnn_1_1step_R2_maskV_-1.0=-0.011259194, rnn_1_1step_CC_maskV_-1.0=0.055326276, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0904607, val_rnn_1_1step_R2_maskV_-1.0=-0.043288514, val_rnn_1_1step_CC_maskV_-1.0=0.23607892, learning_rate=0.001\n", + "Epoch 17/158 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.68510008, rnn_1_1step_R2_maskV_-1.0=0.30459622, rnn_1_1step_CC_maskV_-1.0=0.56739062, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.81175023, val_rnn_1_1step_R2_maskV_-1.0=0.21984768, val_rnn_1_1step_CC_maskV_-1.0=0.52377635, learning_rate=0.001\n", + "Epoch 33/158 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.55290377, rnn_1_1step_R2_maskV_-1.0=0.43713766, rnn_1_1step_CC_maskV_-1.0=0.67175692, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.70794916, val_rnn_1_1step_R2_maskV_-1.0=0.32023239, val_rnn_1_1step_CC_maskV_-1.0=0.59193164, learning_rate=0.001\n", + "Epoch 49/158 - loss=rnn_1_1step_loss=0.4256258, rnn_1_1step_R2_maskV_-1.0=0.56528848, rnn_1_1step_CC_maskV_-1.0=0.76003528, rnn_1_1step_MSE_maskV_-1.0=0.42562577, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59009361, val_rnn_1_1step_R2_maskV_-1.0=0.43454519, val_rnn_1_1step_CC_maskV_-1.0=0.67449212, learning_rate=0.001\n", + "Epoch 65/158 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.34023023, rnn_1_1step_R2_maskV_-1.0=0.65241396, rnn_1_1step_CC_maskV_-1.0=0.81422615, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49059263, val_rnn_1_1step_R2_maskV_-1.0=0.53071225, val_rnn_1_1step_CC_maskV_-1.0=0.7379095, learning_rate=0.001\n", + "Epoch 81/158 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.28760853, rnn_1_1step_R2_maskV_-1.0=0.70631576, rnn_1_1step_CC_maskV_-1.0=0.84558129, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.44962659, val_rnn_1_1step_R2_maskV_-1.0=0.57034695, val_rnn_1_1step_CC_maskV_-1.0=0.76320213, learning_rate=0.001\n", + "Epoch 97/158 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.25051031, rnn_1_1step_R2_maskV_-1.0=0.74458724, rnn_1_1step_CC_maskV_-1.0=0.86703897, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.426373, val_rnn_1_1step_R2_maskV_-1.0=0.59251744, val_rnn_1_1step_CC_maskV_-1.0=0.77748436, learning_rate=0.001\n", + "Epoch 113/158 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.22438695, rnn_1_1step_R2_maskV_-1.0=0.77124876, rnn_1_1step_CC_maskV_-1.0=0.88208443, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41160932, val_rnn_1_1step_R2_maskV_-1.0=0.60559672, val_rnn_1_1step_CC_maskV_-1.0=0.78570199, learning_rate=0.001\n", + "Epoch 129/158 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.20493877, rnn_1_1step_R2_maskV_-1.0=0.79042417, rnn_1_1step_CC_maskV_-1.0=0.89267856, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.40372863, val_rnn_1_1step_R2_maskV_-1.0=0.61243689, val_rnn_1_1step_CC_maskV_-1.0=0.79065496, learning_rate=0.001\n", + "Epoch 145/158 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.18974151, rnn_1_1step_R2_maskV_-1.0=0.8062492, rnn_1_1step_CC_maskV_-1.0=0.90096998, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.39462519, val_rnn_1_1step_R2_maskV_-1.0=0.62108278, val_rnn_1_1step_CC_maskV_-1.0=0.7969985, learning_rate=0.001\n", + "Epoch 158/158 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.18349265, rnn_1_1step_R2_maskV_-1.0=0.81311673, rnn_1_1step_CC_maskV_-1.0=0.90504873, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.39737764, val_rnn_1_1step_R2_maskV_-1.0=0.61763394, val_rnn_1_1step_CC_maskV_-1.0=0.79653668, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 12:59:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 18.32s\n", + "\u001b[32m2025-05-30 12:59:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.38253808)\n", + "\u001b[32m2025-05-30 13:00:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.167, R2_maskV_-1.0=0.833, CC_maskV_-1.0=0.913\n", + "\u001b[32m2025-05-30 13:00:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.353, R2_maskV_-1.0=0.657, CC_maskV_-1.0=0.818\n", + "\u001b[32m2025-05-30 13:00:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 13:00:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 13:00:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 132 (stopped at 147 epochs).\n", + "\u001b[32m2025-05-30 13:00:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/148 - loss=1.5801346, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.064896174, MSE_maskV_-1.0=1.5797185, val_loss=1.0780833, val_CC_maskV_-1.0=0.11761694, val_MSE_maskV_-1.0=1.0727068, learning_rate=0.001\n", + "Epoch 16/148 - loss=0.82347536, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42153344, MSE_maskV_-1.0=0.82351315, val_loss=0.90128517, val_CC_maskV_-1.0=0.39094895, val_MSE_maskV_-1.0=0.89803964, learning_rate=0.001\n", + "Epoch 31/148 - loss=0.77936822, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4715564, MSE_maskV_-1.0=0.77893507, val_loss=0.86383969, val_CC_maskV_-1.0=0.43404159, val_MSE_maskV_-1.0=0.86031955, learning_rate=0.001\n", + "Epoch 46/148 - loss=0.75600612, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49445304, MSE_maskV_-1.0=0.75638103, val_loss=0.84737921, val_CC_maskV_-1.0=0.45157018, val_MSE_maskV_-1.0=0.84326231, learning_rate=0.001\n", + "Epoch 61/148 - loss=0.74102032, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50998712, MSE_maskV_-1.0=0.7412203, val_loss=0.82750523, val_CC_maskV_-1.0=0.47068259, val_MSE_maskV_-1.0=0.82364184, learning_rate=0.001\n", + "Epoch 76/148 - loss=0.73194659, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51842797, MSE_maskV_-1.0=0.73219115, val_loss=0.82690024, val_CC_maskV_-1.0=0.47185516, val_MSE_maskV_-1.0=0.823237, learning_rate=0.001\n", + "Epoch 91/148 - loss=0.72494727, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52514631, MSE_maskV_-1.0=0.72502452, val_loss=0.8176918, val_CC_maskV_-1.0=0.48134437, val_MSE_maskV_-1.0=0.81314474, learning_rate=0.001\n", + "Epoch 106/148 - loss=0.72033465, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52971131, MSE_maskV_-1.0=0.72000962, val_loss=0.81541586, val_CC_maskV_-1.0=0.48347753, val_MSE_maskV_-1.0=0.81162524, learning_rate=0.001\n", + "Epoch 121/148 - loss=0.71636534, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53345954, MSE_maskV_-1.0=0.71692926, val_loss=0.80888689, val_CC_maskV_-1.0=0.48746446, val_MSE_maskV_-1.0=0.80511338, learning_rate=0.001\n", + "Epoch 136/148 - loss=0.71403289, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5356729, MSE_maskV_-1.0=0.71394324, val_loss=0.80455452, val_CC_maskV_-1.0=0.4917497, val_MSE_maskV_-1.0=0.8004511, learning_rate=0.001\n", + "Epoch 148/148 - loss=0.71242183, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53637177, MSE_maskV_-1.0=0.71176654, val_loss=0.81178868, val_CC_maskV_-1.0=0.48639402, val_MSE_maskV_-1.0=0.80779064, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 13:00:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 39.47s\n", + "\u001b[32m2025-05-30 13:00:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 13:01:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 132 (stopped at 147 epochs).\n", + "\u001b[32m2025-05-30 13:01:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/148 - loss=1.6690686, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.073839106, MSE_maskV_-1.0=1.6684808, val_loss=1.0759903, val_CC_maskV_-1.0=0.13472539, val_MSE_maskV_-1.0=1.0691731, learning_rate=0.001\n", + "Epoch 16/148 - loss=0.81907368, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42669499, MSE_maskV_-1.0=0.81914401, val_loss=0.90471578, val_CC_maskV_-1.0=0.38816082, val_MSE_maskV_-1.0=0.90104538, learning_rate=0.001\n", + "Epoch 31/148 - loss=0.77493739, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47622544, MSE_maskV_-1.0=0.77447796, val_loss=0.86508912, val_CC_maskV_-1.0=0.43485951, val_MSE_maskV_-1.0=0.86126357, learning_rate=0.001\n", + "Epoch 46/148 - loss=0.75398356, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49659821, MSE_maskV_-1.0=0.75429761, val_loss=0.84662116, val_CC_maskV_-1.0=0.45426941, val_MSE_maskV_-1.0=0.84226286, learning_rate=0.001\n", + "Epoch 61/148 - loss=0.7415939, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50931156, MSE_maskV_-1.0=0.74176878, val_loss=0.83582228, val_CC_maskV_-1.0=0.46359351, val_MSE_maskV_-1.0=0.83196938, learning_rate=0.001\n", + "Epoch 76/148 - loss=0.73291624, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51763588, MSE_maskV_-1.0=0.73319906, val_loss=0.82803887, val_CC_maskV_-1.0=0.4710834, val_MSE_maskV_-1.0=0.82475191, learning_rate=0.001\n", + "Epoch 91/148 - loss=0.72771102, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52242345, MSE_maskV_-1.0=0.72782451, val_loss=0.82485449, val_CC_maskV_-1.0=0.47460341, val_MSE_maskV_-1.0=0.82092279, learning_rate=0.001\n", + "Epoch 106/148 - loss=0.72198272, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52825308, MSE_maskV_-1.0=0.72168827, val_loss=0.81904918, val_CC_maskV_-1.0=0.47929385, val_MSE_maskV_-1.0=0.81589389, learning_rate=0.001\n", + "Epoch 121/148 - loss=0.71956027, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53056979, MSE_maskV_-1.0=0.72012526, val_loss=0.81790298, val_CC_maskV_-1.0=0.47880667, val_MSE_maskV_-1.0=0.81476212, learning_rate=0.001\n", + "Epoch 136/148 - loss=0.71651644, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53335851, MSE_maskV_-1.0=0.71640211, val_loss=0.81120867, val_CC_maskV_-1.0=0.48570585, val_MSE_maskV_-1.0=0.80787444, learning_rate=0.001\n", + "Epoch 148/148 - loss=0.71374458, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53539652, MSE_maskV_-1.0=0.71313393, val_loss=0.81683052, val_CC_maskV_-1.0=0.4807241, val_MSE_maskV_-1.0=0.81353432, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 13:01:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 39.42s\n", + "\u001b[32m2025-05-30 13:01:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.80111986)\n", + "\u001b[32m2025-05-30 13:01:19\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 800us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 13:01:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.712, R2_maskV_-1.0=0.285, CC_maskV_-1.0=0.538\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 904us/step\n", + "51/51 [==============================] - 0s 790us/step\n", + "84/84 [==============================] - 0s 685us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 13:01:20\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_KCzCy1HL64U_ErSV16\" (15/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_KCzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 13:01:20\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16\" (16/16)\n", + "\u001b[32m2025-05-30 13:01:20\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 13:01:20\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 13:01:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 13:01:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 13:01:20\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 13:01:20\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 13:01:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 13:01:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 229 (stopped at 244 epochs).\n", + "\u001b[32m2025-05-30 13:01:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/245 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.00591, rnn_1step_R2_maskV_-1.0=-0.011338409, rnn_1step_CC_maskV_-1.0=0.026846908, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.090649, val_rnn_1step_R2_maskV_-1.0=-0.043491334, val_rnn_1step_CC_maskV_-1.0=0.2231819, learning_rate=0.001\n", + "Epoch 26/245 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.60404634, rnn_1step_R2_maskV_-1.0=0.38536483, rnn_1step_CC_maskV_-1.0=0.63206255, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.73898077, val_rnn_1step_R2_maskV_-1.0=0.28683138, val_rnn_1step_CC_maskV_-1.0=0.56939274, learning_rate=0.001\n", + "Epoch 51/245 - loss=rnn_1step_loss=0.46550933, rnn_1step_R2_maskV_-1.0=0.52443337, rnn_1step_CC_maskV_-1.0=0.73235869, rnn_1step_MSE_maskV_-1.0=0.46550936, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64761186, val_rnn_1step_R2_maskV_-1.0=0.3785744, val_rnn_1step_CC_maskV_-1.0=0.63582277, learning_rate=0.001\n", + "Epoch 76/245 - loss=rnn_1step_loss=0.36335436, rnn_1step_R2_maskV_-1.0=0.62725222, rnn_1step_CC_maskV_-1.0=0.79932064, rnn_1step_MSE_maskV_-1.0=0.36335438, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55326587, val_rnn_1step_R2_maskV_-1.0=0.46841741, val_rnn_1step_CC_maskV_-1.0=0.70048487, learning_rate=0.001\n", + "Epoch 101/245 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30014428, rnn_1step_R2_maskV_-1.0=0.69058692, rnn_1step_CC_maskV_-1.0=0.83774477, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5457747, val_rnn_1step_R2_maskV_-1.0=0.47563633, val_rnn_1step_CC_maskV_-1.0=0.70841503, learning_rate=0.001\n", + "Epoch 126/245 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.26599908, rnn_1step_R2_maskV_-1.0=0.72529262, rnn_1step_CC_maskV_-1.0=0.8578074, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52278733, val_rnn_1step_R2_maskV_-1.0=0.49889734, val_rnn_1step_CC_maskV_-1.0=0.72180301, learning_rate=0.001\n", + "Epoch 151/245 - loss=rnn_1step_loss=0.24301827, rnn_1step_R2_maskV_-1.0=0.74928772, rnn_1step_CC_maskV_-1.0=0.87101066, rnn_1step_MSE_maskV_-1.0=0.24301824, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52493006, val_rnn_1step_R2_maskV_-1.0=0.49696636, val_rnn_1step_CC_maskV_-1.0=0.72101587, learning_rate=0.001\n", + "Epoch 176/245 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.22163273, rnn_1step_R2_maskV_-1.0=0.77125508, rnn_1step_CC_maskV_-1.0=0.88307214, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51409513, val_rnn_1step_R2_maskV_-1.0=0.50722426, val_rnn_1step_CC_maskV_-1.0=0.7282086, learning_rate=0.001\n", + "Epoch 201/245 - loss=rnn_1step_loss=0.20530634, rnn_1step_R2_maskV_-1.0=0.78875285, rnn_1step_CC_maskV_-1.0=0.89286804, rnn_1step_MSE_maskV_-1.0=0.20530635, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5174498, val_rnn_1step_R2_maskV_-1.0=0.50344706, val_rnn_1step_CC_maskV_-1.0=0.730147, learning_rate=0.001\n", + "Epoch 226/245 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.18676282, rnn_1step_R2_maskV_-1.0=0.80773914, rnn_1step_CC_maskV_-1.0=0.9026432, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49722099, val_rnn_1step_R2_maskV_-1.0=0.52310622, val_rnn_1step_CC_maskV_-1.0=0.74234015, learning_rate=0.001\n", + "Epoch 245/245 - loss=rnn_1step_loss=0.17959644, rnn_1step_R2_maskV_-1.0=0.81502157, rnn_1step_CC_maskV_-1.0=0.90732259, rnn_1step_MSE_maskV_-1.0=0.17959645, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5028531, val_rnn_1step_R2_maskV_-1.0=0.51614791, val_rnn_1step_CC_maskV_-1.0=0.7386874, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 13:01:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 27.90s\n", + "\u001b[32m2025-05-30 13:01:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 13:02:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 101 (stopped at 116 epochs).\n", + "\u001b[32m2025-05-30 13:02:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/117 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0058814, rnn_1_1step_R2_maskV_-1.0=-0.011316184, rnn_1_1step_CC_maskV_-1.0=0.047752492, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.091055, val_rnn_1_1step_R2_maskV_-1.0=-0.043918222, val_rnn_1_1step_CC_maskV_-1.0=0.16889028, learning_rate=0.001\n", + "Epoch 13/117 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.78733903, rnn_1_1step_R2_maskV_-1.0=0.20286065, rnn_1_1step_CC_maskV_-1.0=0.47536063, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.87951231, val_rnn_1_1step_R2_maskV_-1.0=0.15728492, val_rnn_1_1step_CC_maskV_-1.0=0.46396041, learning_rate=0.001\n", + "Epoch 25/117 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.60729313, rnn_1_1step_R2_maskV_-1.0=0.38244817, rnn_1_1step_CC_maskV_-1.0=0.62955481, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.74369115, val_rnn_1_1step_R2_maskV_-1.0=0.2815724, val_rnn_1_1step_CC_maskV_-1.0=0.56971514, learning_rate=0.001\n", + "Epoch 37/117 - loss=rnn_1_1step_loss=0.51083326, rnn_1_1step_R2_maskV_-1.0=0.47815865, rnn_1_1step_CC_maskV_-1.0=0.70089704, rnn_1_1step_MSE_maskV_-1.0=0.51083332, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65909284, val_rnn_1_1step_R2_maskV_-1.0=0.36806607, val_rnn_1_1step_CC_maskV_-1.0=0.62701684, learning_rate=0.001\n", + "Epoch 49/117 - loss=rnn_1_1step_loss=0.45219207, rnn_1_1step_R2_maskV_-1.0=0.53714466, rnn_1_1step_CC_maskV_-1.0=0.74156702, rnn_1_1step_MSE_maskV_-1.0=0.4521921, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61187649, val_rnn_1_1step_R2_maskV_-1.0=0.41534203, val_rnn_1_1step_CC_maskV_-1.0=0.65914768, learning_rate=0.001\n", + "Epoch 61/117 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39876667, rnn_1_1step_R2_maskV_-1.0=0.59086376, rnn_1_1step_CC_maskV_-1.0=0.77779418, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55775571, val_rnn_1_1step_R2_maskV_-1.0=0.46622729, val_rnn_1_1step_CC_maskV_-1.0=0.69603205, learning_rate=0.001\n", + "Epoch 73/117 - loss=rnn_1_1step_loss=0.355221, rnn_1_1step_R2_maskV_-1.0=0.63562214, rnn_1_1step_CC_maskV_-1.0=0.80510116, rnn_1_1step_MSE_maskV_-1.0=0.35522097, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49784407, val_rnn_1_1step_R2_maskV_-1.0=0.52464986, val_rnn_1_1step_CC_maskV_-1.0=0.73400962, learning_rate=0.001\n", + "Epoch 85/117 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33706513, rnn_1_1step_R2_maskV_-1.0=0.65299749, rnn_1_1step_CC_maskV_-1.0=0.81646544, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48838386, val_rnn_1_1step_R2_maskV_-1.0=0.53371334, val_rnn_1_1step_CC_maskV_-1.0=0.74050683, learning_rate=0.001\n", + "Epoch 97/117 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31350771, rnn_1_1step_R2_maskV_-1.0=0.67783606, rnn_1_1step_CC_maskV_-1.0=0.82990193, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46621108, val_rnn_1_1step_R2_maskV_-1.0=0.55522805, val_rnn_1_1step_CC_maskV_-1.0=0.75467533, learning_rate=0.001\n", + "Epoch 109/117 - loss=rnn_1_1step_loss=0.29881585, rnn_1_1step_R2_maskV_-1.0=0.69250256, rnn_1_1step_CC_maskV_-1.0=0.83884656, rnn_1_1step_MSE_maskV_-1.0=0.29881588, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48923671, val_rnn_1_1step_R2_maskV_-1.0=0.53353786, val_rnn_1_1step_CC_maskV_-1.0=0.73881471, learning_rate=0.001\n", + "Epoch 117/117 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.29066709, rnn_1_1step_R2_maskV_-1.0=0.70167375, rnn_1_1step_CC_maskV_-1.0=0.84458947, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46516204, val_rnn_1_1step_R2_maskV_-1.0=0.55681872, val_rnn_1_1step_CC_maskV_-1.0=0.75411254, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 13:02:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.06s\n", + "\u001b[32m2025-05-30 13:02:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.46421468)\n", + "\u001b[32m2025-05-30 13:02:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.285, R2_maskV_-1.0=0.715, CC_maskV_-1.0=0.846\n", + "\u001b[32m2025-05-30 13:02:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.447, R2_maskV_-1.0=0.564, CC_maskV_-1.0=0.761\n", + "\u001b[32m2025-05-30 13:02:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 13:02:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 13:02:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 180 (stopped at 195 epochs).\n", + "\u001b[32m2025-05-30 13:02:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/196 - loss=1.2200668, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.12199865, MSE_maskV_-1.0=1.2206632, val_loss=1.0236485, val_CC_maskV_-1.0=0.1916745, val_MSE_maskV_-1.0=1.0180992, learning_rate=0.001\n", + "Epoch 21/196 - loss=0.80448449, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44350368, MSE_maskV_-1.0=0.80439502, val_loss=0.88502866, val_CC_maskV_-1.0=0.40118673, val_MSE_maskV_-1.0=0.88143432, learning_rate=0.001\n", + "Epoch 41/196 - loss=0.76536214, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4853763, MSE_maskV_-1.0=0.76505709, val_loss=0.84412056, val_CC_maskV_-1.0=0.4417794, val_MSE_maskV_-1.0=0.84065264, learning_rate=0.001\n", + "Epoch 61/196 - loss=0.74607873, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50458658, MSE_maskV_-1.0=0.74602616, val_loss=0.82539463, val_CC_maskV_-1.0=0.4583903, val_MSE_maskV_-1.0=0.82226717, learning_rate=0.001\n", + "Epoch 81/196 - loss=0.73533732, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51381987, MSE_maskV_-1.0=0.73555398, val_loss=0.81746495, val_CC_maskV_-1.0=0.46510422, val_MSE_maskV_-1.0=0.81446576, learning_rate=0.001\n", + "Epoch 101/196 - loss=0.72745365, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52150202, MSE_maskV_-1.0=0.72756088, val_loss=0.80881786, val_CC_maskV_-1.0=0.47365525, val_MSE_maskV_-1.0=0.80550116, learning_rate=0.001\n", + "Epoch 121/196 - loss=0.72124791, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52798378, MSE_maskV_-1.0=0.72169626, val_loss=0.81042564, val_CC_maskV_-1.0=0.47110644, val_MSE_maskV_-1.0=0.80735976, learning_rate=0.001\n", + "Epoch 141/196 - loss=0.71583933, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53248841, MSE_maskV_-1.0=0.71590412, val_loss=0.80545336, val_CC_maskV_-1.0=0.4755609, val_MSE_maskV_-1.0=0.80214787, learning_rate=0.001\n", + "Epoch 161/196 - loss=0.71094459, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53668219, MSE_maskV_-1.0=0.71112895, val_loss=0.79686761, val_CC_maskV_-1.0=0.48232841, val_MSE_maskV_-1.0=0.79358208, learning_rate=0.001\n", + "Epoch 181/196 - loss=0.7065888, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54058945, MSE_maskV_-1.0=0.70640695, val_loss=0.79245251, val_CC_maskV_-1.0=0.48836967, val_MSE_maskV_-1.0=0.78931075, learning_rate=0.001\n", + "Epoch 196/196 - loss=0.70468962, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54236758, MSE_maskV_-1.0=0.70546657, val_loss=0.79283285, val_CC_maskV_-1.0=0.48688656, val_MSE_maskV_-1.0=0.78965938, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 13:02:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 50.77s\n", + "\u001b[32m2025-05-30 13:02:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 13:04:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 272 (stopped at 287 epochs).\n", + "\u001b[32m2025-05-30 13:04:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/288 - loss=1.1221395, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.13117753, MSE_maskV_-1.0=1.1229613, val_loss=1.0267644, val_CC_maskV_-1.0=0.18973726, val_MSE_maskV_-1.0=1.0212162, learning_rate=0.001\n", + "Epoch 30/288 - loss=0.78523201, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46466735, MSE_maskV_-1.0=0.78548729, val_loss=0.86651987, val_CC_maskV_-1.0=0.42089108, val_MSE_maskV_-1.0=0.8629694, learning_rate=0.001\n", + "Epoch 59/288 - loss=0.75165713, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.498669, MSE_maskV_-1.0=0.75118625, val_loss=0.83216292, val_CC_maskV_-1.0=0.45278406, val_MSE_maskV_-1.0=0.82903689, learning_rate=0.001\n", + "Epoch 88/288 - loss=0.73676163, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51359302, MSE_maskV_-1.0=0.73609859, val_loss=0.81764638, val_CC_maskV_-1.0=0.46706137, val_MSE_maskV_-1.0=0.81424952, learning_rate=0.001\n", + "Epoch 117/288 - loss=0.72534502, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52352041, MSE_maskV_-1.0=0.72507715, val_loss=0.80924499, val_CC_maskV_-1.0=0.47549179, val_MSE_maskV_-1.0=0.80588561, learning_rate=0.001\n", + "Epoch 146/288 - loss=0.71755981, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53093171, MSE_maskV_-1.0=0.7186299, val_loss=0.80220926, val_CC_maskV_-1.0=0.47984475, val_MSE_maskV_-1.0=0.79881161, learning_rate=0.001\n", + "Epoch 175/288 - loss=0.7122885, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53505862, MSE_maskV_-1.0=0.71210212, val_loss=0.79656082, val_CC_maskV_-1.0=0.48400041, val_MSE_maskV_-1.0=0.79323483, learning_rate=0.001\n", + "Epoch 204/288 - loss=0.70571089, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54096466, MSE_maskV_-1.0=0.70587438, val_loss=0.79205632, val_CC_maskV_-1.0=0.48850593, val_MSE_maskV_-1.0=0.78873658, learning_rate=0.001\n", + "Epoch 233/288 - loss=0.70116276, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54516459, MSE_maskV_-1.0=0.70071054, val_loss=0.7861383, val_CC_maskV_-1.0=0.49312532, val_MSE_maskV_-1.0=0.7826677, learning_rate=0.001\n", + "Epoch 262/288 - loss=0.69727707, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54872364, MSE_maskV_-1.0=0.69697565, val_loss=0.78303814, val_CC_maskV_-1.0=0.49697086, val_MSE_maskV_-1.0=0.779908, learning_rate=0.001\n", + "Epoch 288/288 - loss=0.69593304, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54965931, MSE_maskV_-1.0=0.69675171, val_loss=0.77782059, val_CC_maskV_-1.0=0.50042135, val_MSE_maskV_-1.0=0.77462357, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 13:04:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 75.85s\n", + "\u001b[32m2025-05-30 13:04:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.77628225)\n", + "\u001b[32m2025-05-30 13:04:11\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 785us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 13:04:12\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.691, R2_maskV_-1.0=0.31, CC_maskV_-1.0=0.556\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 853us/step\n", + "51/51 [==============================] - 0s 824us/step\n", + "84/84 [==============================] - 0s 763us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 13:04:13\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16\" (16/16) in \"..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_uAKCzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 13:04:13\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1948] \u001b[1;30mINFO\u001b[0m Saving results for fold 4 as ..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4.p\n", + "\u001b[32m2025-05-30 13:04:14\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 4212] \u001b[1;30mINFO\u001b[0m Saving the results in ..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p\n", + "\u001b[32m2025-05-30 13:04:14\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 4110] \u001b[1;30mINFO\u001b[0m Checking whether result file size could be reduced for future loads\n", + "\u001b[32m2025-05-30 13:04:14\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 4199] \u001b[1;30mINFO\u001b[0m Could not reduce file size\n", + "\u001b[32m2025-05-30 13:04:14\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 320] \u001b[1;30mINFO\u001b[0m Selecting among the 16 tried method variants based on the inner CV results: \n", + "\u001b[32m2025-05-30 13:04:14\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 395] \u001b[1;30mINFO\u001b[0m - Preaveraging yCC across the 4 folds => sem will be 0 and will pick the case with best yCC\n", + "\u001b[32m2025-05-30 13:04:14\u001b[0m \u001b[34mDPAD.tools.evaluation\u001b[0m [evaluation.py > 569] \u001b[1;30mINFO\u001b[0m Of 16 cases, the following were within 1 sem of the best CC in each session:\n", + "[ 8 14]\n", + "\u001b[32m2025-05-30 13:04:14\u001b[0m \u001b[34mDPAD.tools.evaluation\u001b[0m [evaluation.py > 585] \u001b[1;30mINFO\u001b[0m Criteria 2: yCC\n", + "Of 16 cases, the following were within 1 sem of the best yCC in each session:\n", + "[13]\n", + "\u001b[32m2025-05-30 13:04:14\u001b[0m \u001b[34mDPAD.tools.evaluation\u001b[0m [evaluation.py > 606] \u001b[1;30mINFO\u001b[0m - In 0/1 sessions ([]) some cases satisfied both criteria, will pick among those.\n", + "\u001b[32m2025-05-30 13:04:14\u001b[0m \u001b[34mDPAD.tools.evaluation\u001b[0m [evaluation.py > 613] \u001b[1;30mINFO\u001b[0m - In 1/1 sessions ([0]), no case satisfied both criteria, so will pick the case with best criteria 2 (yCC) among those that satisfy criteria 1 (CC).\n", + "\u001b[32m2025-05-30 13:04:14\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 425] \u001b[1;30mINFO\u001b[0m Picked the following method after inner CV: (index 14) DPAD_RTR2_KCzCy1HL64U_ErSV16\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "Selected nonlinearity setting: DPAD_RTR2_KCzCy1HL64U_ErSV16\n" + ] + } + ], + "source": [ + "## Step 1.1: Finding optimal nonlinearity:\n", + "# The following function searches over possible nonlinearities and picks the best one based on the training data\n", + "settings = {}\n", + "settings[\"min_cores_to_enable_parallelization\"] = 100 # If fewer than this many cores are available, code will not run with parallelization,\n", + "# set to a large number to disable parallelization. This should be smaller than the total number of cores your machine has, and even then, \n", + "# depending on available memory and machine specs, parallel runs may lead to the OS freezing. \n", + "# If that happens, to disable parallelization completely, set `min_cores_to_enable_parallelization` to a number larger than the number of \n", + "# cores than the machine has (e.g. you can set it to 1000). \n", + "\n", + "settings['fit_epochs'] = 2500 # Fitting will stop upon convergence or after at most the specified number of epochs. The default (2500 epochs) is\n", + "# usually more than enough.\n", + "\n", + "methodCode = \"DPAD_GSUT_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\" # sess 1, 2\n", + "# This considers 16 cases: Each of the 4 mappings with zero (linear) or 1 hidden layer with 64 unit.\n", + "# It also uses 4 inner cross validations (`iCV4`) and two random sets of initial parameters (`RTR2`), \n", + "# and stops learning even before 2500 epochs as soon as the loss for validation data (last 20% of training data)\n", + "# doesn't improve for 16 epochs (`ErSV16`).\n", + "\n", + "saveDir = os.path.join(\"..\", \"..\", \"..\", \"results\") # Where you want the fitting results to be saved\n", + "\n", + "# This functions needs to be called for each session, fold and state dimension. Here we only run it for fold 1 of session 1 and with fixed state dimensions of nx=n1=16 as an example\n", + "selectedMethodCode, iCVRes = fitDPADWithFlexibleNonlinearity(\n", + " yTrain, Z=zTrain, nx=nx, n1=n1, settings=settings, methodCode=methodCode, saveDir=saveDir)\n", + "\n", + "print(f'\\n\\nSelected nonlinearity setting: {selectedMethodCode}')\n", + "\n", + "# Typical runtime for this step:\n", + "# - For any individual nonlinearity: a couple of minutes\n", + "# - For flexible search over all nonlinearity options:\n", + "# + Without parallelization: sum of run times for all considered nonlinearity options\n", + "# + With full parallelization: max of run time across all considered nonlinearity options" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As the last line of the log shows, in this example the optimal nonlinearity giving rise to best behavior (z) decoding is: `DPAD_RTR2_KCzCy1HL64U_ErSV16` : $K$, $C_z$ and $C_y$ nonlinear." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**What is the next step?** \n", + "\n", + "- To continue with flexible DPAD, we next need to fit one final model with the selected nonlinearity setup and using all the training data. For this, you need to set `methodCode=selectedMethodCode` (for best behavior decoding i.e., default) or `methodCode=selectedMethodCode_y` (for best neural self-prediction) obtained above and run DPAD again according to next section.\n", + "\n", + "- You can alternatively set `methodCode` manually to run DPAD with your desired user-defined nonlinearity e.g., nonlinear Cz: `methodCode='DPAD_RTR2_Cz1HL64U_ErSV16'`. Please see `2. DPAD with user-defined nonlinearity` above for more explanation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 13:46:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 13:46:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 13:46:55\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 13:46:55\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 16 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 13:46:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 13:47:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 109 (stopped at 124 epochs).\n", + "\u001b[32m2025-05-30 13:47:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/125 - loss=rnn_1step_loss=rnn_1step_mse=1.0875728, rnn_1step_R2_maskV_None=-0.02287659, rnn_1step_CC_maskV_None=0.081162825, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.94982678, val_rnn_1step_R2_maskV_None=-0.046091959, val_rnn_1step_CC_maskV_None=0.31059524, learning_rate=0.001\n", + "Epoch 14/125 - loss=rnn_1step_loss=rnn_1step_mse=0.72170705, rnn_1step_R2_maskV_None=0.21364689, rnn_1step_CC_maskV_None=0.58570147, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.6272018, val_rnn_1step_R2_maskV_None=0.18041816, val_rnn_1step_CC_maskV_None=0.59001732, learning_rate=0.001\n", + "Epoch 27/125 - loss=rnn_1step_loss=rnn_1step_mse=0.55842578, rnn_1step_R2_maskV_None=0.32220247, rnn_1step_CC_maskV_None=0.6956659, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.55346382, val_rnn_1step_R2_maskV_None=0.24913536, val_rnn_1step_CC_maskV_None=0.65893877, learning_rate=0.001\n", + "Epoch 40/125 - loss=rnn_1step_loss=rnn_1step_mse=0.51572746, rnn_1step_R2_maskV_None=0.35434163, rnn_1step_CC_maskV_None=0.72290027, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.52411258, val_rnn_1step_R2_maskV_None=0.27900136, val_rnn_1step_CC_maskV_None=0.68079537, learning_rate=0.001\n", + "Epoch 53/125 - loss=rnn_1step_loss=rnn_1step_mse=0.46873629, rnn_1step_R2_maskV_None=0.39332885, rnn_1step_CC_maskV_None=0.75220013, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.48628795, val_rnn_1step_R2_maskV_None=0.32061517, val_rnn_1step_CC_maskV_None=0.70663309, learning_rate=0.001\n", + "Epoch 66/125 - loss=rnn_1step_loss=rnn_1step_mse=0.42787421, rnn_1step_R2_maskV_None=0.43799245, rnn_1step_CC_maskV_None=0.77685964, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.4624635, val_rnn_1step_R2_maskV_None=0.35331184, val_rnn_1step_CC_maskV_None=0.72326946, learning_rate=0.001\n", + "Epoch 79/125 - loss=rnn_1step_loss=rnn_1step_mse=0.39130199, rnn_1step_R2_maskV_None=0.4831228, rnn_1step_CC_maskV_None=0.79836035, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.45101532, val_rnn_1step_R2_maskV_None=0.37046993, val_rnn_1step_CC_maskV_None=0.73249716, learning_rate=0.001\n", + "Epoch 92/125 - loss=rnn_1step_loss=rnn_1step_mse=0.35742694, rnn_1step_R2_maskV_None=0.52729273, rnn_1step_CC_maskV_None=0.81781381, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.44334227, val_rnn_1step_R2_maskV_None=0.3830137, val_rnn_1step_CC_maskV_None=0.74003351, learning_rate=0.001\n", + "Epoch 105/125 - loss=rnn_1step_loss=rnn_1step_mse=0.33014542, rnn_1step_R2_maskV_None=0.5643698, rnn_1step_CC_maskV_None=0.83318996, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.43814299, val_rnn_1step_R2_maskV_None=0.39289743, val_rnn_1step_CC_maskV_None=0.74585932, learning_rate=0.001\n", + "Epoch 118/125 - loss=rnn_1step_loss=rnn_1step_mse=0.3082642, rnn_1step_R2_maskV_None=0.59437108, rnn_1step_CC_maskV_None=0.84530807, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.43838158, val_rnn_1step_R2_maskV_None=0.39687023, val_rnn_1step_CC_maskV_None=0.74807197, learning_rate=0.001\n", + "Epoch 125/125 - loss=rnn_1step_loss=rnn_1step_mse=0.29808536, rnn_1step_R2_maskV_None=0.60872489, rnn_1step_CC_maskV_None=0.85085535, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.44015408, val_rnn_1step_R2_maskV_None=0.39794496, val_rnn_1step_CC_maskV_None=0.74832445, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 13:47:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.06s\n", + "\u001b[32m2025-05-30 13:47:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 13:47:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 203 (stopped at 218 epochs).\n", + "\u001b[32m2025-05-30 13:47:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/219 - loss=rnn_1_1step_loss=rnn_1_1step_mse=1.087708, rnn_1_1step_R2_maskV_None=-0.022962641, rnn_1_1step_CC_maskV_None=0.0763411, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.95034277, val_rnn_1_1step_R2_maskV_None=-0.046817347, val_rnn_1_1step_CC_maskV_None=0.31179953, learning_rate=0.001\n", + "Epoch 23/219 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.56184345, rnn_1_1step_R2_maskV_None=0.31683171, rnn_1_1step_CC_maskV_None=0.69344217, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.55224323, val_rnn_1_1step_R2_maskV_None=0.24906163, val_rnn_1_1step_CC_maskV_None=0.66002101, learning_rate=0.001\n", + "Epoch 45/219 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.45880449, rnn_1_1step_R2_maskV_None=0.4141866, rnn_1_1step_CC_maskV_None=0.75831616, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.47217464, val_rnn_1_1step_R2_maskV_None=0.34041288, val_rnn_1_1step_CC_maskV_None=0.71666902, learning_rate=0.001\n", + "Epoch 67/219 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.39112017, rnn_1_1step_R2_maskV_None=0.49447307, rnn_1_1step_CC_maskV_None=0.79853684, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.44509882, val_rnn_1_1step_R2_maskV_None=0.37532026, val_rnn_1_1step_CC_maskV_None=0.73865205, learning_rate=0.001\n", + "Epoch 89/219 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.34579575, rnn_1_1step_R2_maskV_None=0.55186349, rnn_1_1step_CC_maskV_None=0.82462543, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.43770421, val_rnn_1_1step_R2_maskV_None=0.38623345, val_rnn_1_1step_CC_maskV_None=0.74646729, learning_rate=0.001\n", + "Epoch 111/219 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.30944622, rnn_1_1step_R2_maskV_None=0.59883338, rnn_1_1step_CC_maskV_None=0.84500688, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.42988586, val_rnn_1_1step_R2_maskV_None=0.39875951, val_rnn_1_1step_CC_maskV_None=0.75380641, learning_rate=0.001\n", + "Epoch 133/219 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.27461177, rnn_1_1step_R2_maskV_None=0.64743185, rnn_1_1step_CC_maskV_None=0.86393672, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.42317325, val_rnn_1_1step_R2_maskV_None=0.41464019, val_rnn_1_1step_CC_maskV_None=0.76007557, learning_rate=0.001\n", + "Epoch 155/219 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.23572975, rnn_1_1step_R2_maskV_None=0.7088322, rnn_1_1step_CC_maskV_None=0.88436818, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.40559992, val_rnn_1_1step_R2_maskV_None=0.45086902, val_rnn_1_1step_CC_maskV_None=0.77176797, learning_rate=0.001\n", + "Epoch 177/219 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.20083824, rnn_1_1step_R2_maskV_None=0.76802242, rnn_1_1step_CC_maskV_None=0.90233284, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.38457179, val_rnn_1_1step_R2_maskV_None=0.5061329, val_rnn_1_1step_CC_maskV_None=0.78501266, learning_rate=0.001\n", + "Epoch 199/219 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.18335694, rnn_1_1step_R2_maskV_None=0.7932573, rnn_1_1step_CC_maskV_None=0.91126871, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.37972352, val_rnn_1_1step_R2_maskV_None=0.52901, val_rnn_1_1step_CC_maskV_None=0.7886973, learning_rate=0.001\n", + "Epoch 219/219 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.17378139, rnn_1_1step_R2_maskV_None=0.80263865, rnn_1_1step_CC_maskV_None=0.91631711, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.37914461, val_rnn_1_1step_R2_maskV_None=0.53326768, val_rnn_1_1step_CC_maskV_None=0.79005778, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 13:47:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 22.50s\n", + "\u001b[32m2025-05-30 13:47:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.37621558)\n", + "\u001b[32m2025-05-30 13:47:34\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_None=0.16, R2_maskV_None=0.842, CC_maskV_None=0.924\n", + "\u001b[32m2025-05-30 13:47:34\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_None=0.349, R2_maskV_None=0.602, CC_maskV_None=0.811\n", + "\u001b[32m2025-05-30 13:47:34\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 13:47:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 13:48:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 66 (stopped at 81 epochs).\n", + "\u001b[32m2025-05-30 13:48:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/82 - loss=mse=1.4032298, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.30426946, val_loss=val_mse=1.1670489, val_CC_maskV_None=0.44058141, learning_rate=0.001\n", + "Epoch 10/82 - loss=mse=0.89155763, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.62051195, val_loss=val_mse=0.91464823, val_CC_maskV_None=0.60286254, learning_rate=0.001\n", + "Epoch 19/82 - loss=mse=0.83907288, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.64842021, val_loss=val_mse=0.86225009, val_CC_maskV_None=0.63169372, learning_rate=0.001\n", + "Epoch 28/82 - loss=mse=0.81714761, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.65979189, val_loss=val_mse=0.85360152, val_CC_maskV_None=0.63702774, learning_rate=0.001\n", + "Epoch 37/82 - loss=mse=0.80438489, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.66626054, val_loss=val_mse=0.84598213, val_CC_maskV_None=0.64078611, learning_rate=0.001\n", + "Epoch 46/82 - loss=mse=0.79523993, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.67126542, val_loss=val_mse=0.83173203, val_CC_maskV_None=0.64859074, learning_rate=0.001\n", + "Epoch 55/82 - loss=mse=0.79009145, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.67392969, val_loss=val_mse=0.82811618, val_CC_maskV_None=0.65066695, learning_rate=0.001\n", + "Epoch 64/82 - loss=mse=0.78362405, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.67755252, val_loss=val_mse=0.81937295, val_CC_maskV_None=0.65498132, learning_rate=0.001\n", + "Epoch 73/82 - loss=mse=0.78114152, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.67889518, val_loss=val_mse=0.81951523, val_CC_maskV_None=0.65477997, learning_rate=0.001\n", + "Epoch 82/82 - loss=mse=0.77758676, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.68053055, val_loss=val_mse=0.81961262, val_CC_maskV_None=0.65486366, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 13:48:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 26.66s\n", + "\u001b[32m2025-05-30 13:48:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 13:48:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 152 (stopped at 167 epochs).\n", + "\u001b[32m2025-05-30 13:48:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/168 - loss=mse=1.3744813, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.30921429, val_loss=val_mse=1.1652277, val_CC_maskV_None=0.44035789, learning_rate=0.001\n", + "Epoch 18/168 - loss=mse=0.8447206, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.64503819, val_loss=val_mse=0.86908394, val_CC_maskV_None=0.62903172, learning_rate=0.001\n", + "Epoch 35/168 - loss=mse=0.80921841, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.66324222, val_loss=val_mse=0.83711004, val_CC_maskV_None=0.64571261, learning_rate=0.001\n", + "Epoch 52/168 - loss=mse=0.79332328, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.67291105, val_loss=val_mse=0.82870042, val_CC_maskV_None=0.65037245, learning_rate=0.001\n", + "Epoch 69/168 - loss=mse=0.78371525, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.67683464, val_loss=val_mse=0.81607121, val_CC_maskV_None=0.6565066, learning_rate=0.001\n", + "Epoch 86/168 - loss=mse=0.77725363, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.68032652, val_loss=val_mse=0.81401014, val_CC_maskV_None=0.65785283, learning_rate=0.001\n", + "Epoch 103/168 - loss=mse=0.77409941, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.68240535, val_loss=val_mse=0.81971025, val_CC_maskV_None=0.65490276, learning_rate=0.001\n", + "Epoch 120/168 - loss=mse=0.76975679, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.68370676, val_loss=val_mse=0.81027132, val_CC_maskV_None=0.65974665, learning_rate=0.001\n", + "Epoch 137/168 - loss=mse=0.76675278, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.6853832, val_loss=val_mse=0.8066082, val_CC_maskV_None=0.66154671, learning_rate=0.001\n", + "Epoch 154/168 - loss=mse=0.76423472, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.6865285, val_loss=val_mse=0.8100701, val_CC_maskV_None=0.6600095, learning_rate=0.001\n", + "Epoch 168/168 - loss=mse=0.76216435, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.68780547, val_loss=val_mse=0.80632663, val_CC_maskV_None=0.66149408, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 13:48:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 54.78s\n", + "\u001b[32m2025-05-30 13:48:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.80085564)\n", + "\u001b[32m2025-05-30 13:48:55\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 268 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "268/268 [==============================] - 0s 760us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 13:48:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_None=0.76, R2_maskV_None=0.29, CC_maskV_None=0.69\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "268/268 [==============================] - 0s 740us/step\n", + "67/67 [==============================] - 0s 844us/step\n" + ] + } + ], + "source": [ + "## Step 1.2: Fitting DPAD with optimal nonlinearity\n", + "## or \n", + "## simply running DPAD with user-defined nonlinearity\n", + "\n", + "# ATTENTION: To find the best nonlinearity setting (i.e., flexible DPAD), you need to first run the previous cell and pass methodCode=selectedMethodCode to this section:\n", + "methodCode = selectedMethodCode\n", + "# Alternatively, to skip the flexible search, you can run this cell on its own by simply setting methodCode to the desired nonlinearity settings. For example, you can set:\n", + "# methodCode = 'DPAD_RTR2_Cz1HL64U_ErSV16' # To run DPAD with nonlinearity in Cz only.\n", + "\n", + "idSysF = DPADModel()\n", + "epochs = 2500 # Default for this is 2500.\n", + "# Fitting will stop upon convergence or after at most the specified number of\n", + "# epochs. 2500 as the max number of epochs is usually more than enough.\n", + "# In addition, the `ErSV16` in the method code enables early stopping based on validation loss. \n", + "# This means that learning can stop even before 2500 epochs, as soon as the loss for validation data \n", + "# (last 20% of training data) doesn't improve for 16 epochs (`ErSV16`). After early stopping\n", + "# the model from the epoch with the best validation loss (which is not going to be the last epoch)\n", + "# is taken as the final learned model.\n", + "\n", + "\n", + "# Prepare settings to make desired parameters in the learned model nonlinear\n", + "args = DPADModel.prepare_args(methodCode)\n", + "idSysF.fit(yTrain.T, Z=zTrain.T, nx=nx, n1=n1, epochs=epochs, **args)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After fitting is done, you can infer the 1-step-ahead predicted states, neural activity and behavior as follows" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing predictions for the learned model with optimal nonlinearity for behavior decoding\n", + "84/84 [==============================] - 0s 771us/step\n", + "Behavior decoding CC:\n", + " Nonlinear DPAD (Flexible; best nonlinearity for behavior decoidng) => 0.793\n" + ] + } + ], + "source": [ + "# Predict behavior and neural activity, from past neural activity, using the learned model\n", + "print(\"Computing predictions for the learned model with optimal nonlinearity for behavior decoding\")\n", + "###########\n", + "zTestPredF, yTestPredF, xTestPredF = idSysF.predict(yTest)\n", + "\n", + "# Compute CC of decoding and self-prediction\n", + "zCCNonLinF = evalPrediction(zTest, zTestPredF, \"CC\")\n", + "yCCNonLinF = evalPrediction(yTest, yTestPredF, \"CC\")\n", + "##########\n", + "\n", + "print(\n", + " f\"Behavior decoding CC:\\n Nonlinear DPAD (Flexible; best nonlinearity for behavior decoidng) => {np.mean(zCCNonLinF):.3g}\"\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plotting losses\n", + "It is very useful for diagnosing issues with over or underfitting to plot a curve of how the loss changes during learning. \n", + "The following command does that." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(
, )" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "idSysF.plot_logs()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each line in the loss plot is the training or validation loss for one optimization step:\n", + "- `model1`: step 1, the RNN that optimizes behavior prediction.\n", + "- `model1_Cy`: step 2, the mapping from the states of the first RNN to neural data.\n", + "We don't have the other two steps here because we used `nx=n1`, but if we did, their losses will also be included in the plot.\n", + "- `model2`: step 3, the RNN that optmizer predictional of any residual neural activity.\n", + "- `model2_Cz`: step 4, the mapping from the states of the second RNN to the behavior.\n", + "See the **Supplementary Fig. 1** and **Methods** in the DPAD paper ([Sani et al, 2024](https://doi.org/10.1038/s41593-024-01731-2)) for details of all optimization steps." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Alternative goal: using neural self-prediction as the metric to select nonlinearity setting\n", + "Let's now run flexible DPAD, but use neural self-prediction as the metric to select the nonlinearity setting. To do this, we add **'y'** to 'GSUT' in the method code as 'GSUTy' and fit the flexible DPAD with this updated method code as follows. Note that this is just changing how the nonlinearity setting is selected, but the fitting of the final DPAD model with the selected nonlinearity will still be entirely optimizing behavior decoding since we have `nx=n1`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:27:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 249] \u001b[1;30mINFO\u001b[0m Running innerCV to choose among the following 16 variants:\n", + "(1) DPAD_RTR2_ErSV16\n", + "(2) DPAD_RTR2_A1HL64U_ErSV16\n", + "(3) DPAD_RTR2_K1HL64U_ErSV16\n", + "(4) DPAD_RTR2_Cz1HL64U_ErSV16\n", + "(5) DPAD_RTR2_Cy1HL64U_ErSV16\n", + "(6) DPAD_RTR2_uAK1HL64U_ErSV16\n", + "(7) DPAD_RTR2_ACz1HL64U_ErSV16\n", + "(8) DPAD_RTR2_ACy1HL64U_ErSV16\n", + "(9) DPAD_RTR2_KCz1HL64U_ErSV16\n", + "(10) DPAD_RTR2_KCy1HL64U_ErSV16\n", + "(11) DPAD_RTR2_CzCy1HL64U_ErSV16\n", + "(12) DPAD_RTR2_uAKCz1HL64U_ErSV16\n", + "(13) DPAD_RTR2_uAKCy1HL64U_ErSV16\n", + "(14) DPAD_RTR2_ACzCy1HL64U_ErSV16\n", + "(15) DPAD_RTR2_KCzCy1HL64U_ErSV16\n", + "(16) DPAD_RTR2_uAKCzCy1HL64U_ErSV16\n", + "\u001b[32m2025-05-30 14:27:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 637] \u001b[1;30mINFO\u001b[0m Assuming new run because no result file was found in ..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p\n", + "\u001b[32m2025-05-30 14:27:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1381] \u001b[1;30mINFO\u001b[0m Fold 1/4: training samples: 8014, test samples=2672\n", + "\u001b[32m2025-05-30 14:27:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1754] \u001b[1;30mINFO\u001b[0m Running fold 1 (NTrain=8014, NTest=2672)\n", + "\u001b[32m2025-05-30 14:27:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1849] \u001b[1;30mINFO\u001b[0m Signal dimensions: y => (10686, 46), z => (10686, 4), u => None\n", + "\u001b[32m2025-05-30 14:27:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1856] \u001b[1;30mINFO\u001b[0m Method codes to fit: ['DPAD_RTR2_ErSV16', 'DPAD_RTR2_A1HL64U_ErSV16', 'DPAD_RTR2_K1HL64U_ErSV16', 'DPAD_RTR2_Cz1HL64U_ErSV16', 'DPAD_RTR2_Cy1HL64U_ErSV16', 'DPAD_RTR2_uAK1HL64U_ErSV16', 'DPAD_RTR2_ACz1HL64U_ErSV16', 'DPAD_RTR2_ACy1HL64U_ErSV16', 'DPAD_RTR2_KCz1HL64U_ErSV16', 'DPAD_RTR2_KCy1HL64U_ErSV16', 'DPAD_RTR2_CzCy1HL64U_ErSV16', 'DPAD_RTR2_uAKCz1HL64U_ErSV16', 'DPAD_RTR2_uAKCy1HL64U_ErSV16', 'DPAD_RTR2_ACzCy1HL64U_ErSV16', 'DPAD_RTR2_KCzCy1HL64U_ErSV16', 'DPAD_RTR2_uAKCzCy1HL64U_ErSV16']\n", + "\u001b[32m2025-05-30 14:27:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1857] \u001b[1;30mINFO\u001b[0m Nx values to fit: [16]\n", + "\u001b[32m2025-05-30 14:27:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_ErSV16\" (1/16)\n", + "\u001b[32m2025-05-30 14:27:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 14:27:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 14:27:31\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Considering 16 possible combinations of location/type for nonlinearities (this might take a while)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:27:31\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 14:27:31\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 14:27:31\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 14:27:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:31:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/2500 - loss=rnn_1step_loss=0.99842739, rnn_1step_R2_maskV_-1.0=-0.021439366, rnn_1step_CC_maskV_-1.0=0.03259721, rnn_1step_MSE_maskV_-1.0=0.99842733, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96488094, val_rnn_1step_R2_maskV_-1.0=-0.087740093, val_rnn_1step_CC_maskV_-1.0=0.057965536, learning_rate=0.001\n", + "Epoch 251/2500 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4227643, rnn_1step_R2_maskV_-1.0=0.56389558, rnn_1step_CC_maskV_-1.0=0.7579869, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53941935, val_rnn_1step_R2_maskV_-1.0=0.38185745, val_rnn_1step_CC_maskV_-1.0=0.68094027, learning_rate=0.001\n", + "Epoch 501/2500 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41515723, rnn_1step_R2_maskV_-1.0=0.57140148, rnn_1step_CC_maskV_-1.0=0.76306331, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53519815, val_rnn_1step_R2_maskV_-1.0=0.38665903, val_rnn_1step_CC_maskV_-1.0=0.68484592, learning_rate=0.001\n", + "Epoch 751/2500 - loss=rnn_1step_loss=0.40880719, rnn_1step_R2_maskV_-1.0=0.57768071, rnn_1step_CC_maskV_-1.0=0.76727825, rnn_1step_MSE_maskV_-1.0=0.40880722, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53001583, val_rnn_1step_R2_maskV_-1.0=0.3926973, val_rnn_1step_CC_maskV_-1.0=0.68834496, learning_rate=0.001\n", + "Epoch 1001/2500 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40740439, rnn_1step_R2_maskV_-1.0=0.57914042, rnn_1step_CC_maskV_-1.0=0.76819491, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52778983, val_rnn_1step_R2_maskV_-1.0=0.39519238, val_rnn_1step_CC_maskV_-1.0=0.6898526, learning_rate=0.001\n", + "Epoch 1251/2500 - loss=rnn_1step_loss=0.40750185, rnn_1step_R2_maskV_-1.0=0.57914174, rnn_1step_CC_maskV_-1.0=0.76809692, rnn_1step_MSE_maskV_-1.0=0.40750191, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52693158, val_rnn_1step_R2_maskV_-1.0=0.39601278, val_rnn_1step_CC_maskV_-1.0=0.69059217, learning_rate=0.001\n", + "Epoch 1501/2500 - loss=rnn_1step_loss=0.407015, rnn_1step_R2_maskV_-1.0=0.57972836, rnn_1step_CC_maskV_-1.0=0.76839471, rnn_1step_MSE_maskV_-1.0=0.40701503, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52514291, val_rnn_1step_R2_maskV_-1.0=0.39798424, val_rnn_1step_CC_maskV_-1.0=0.69187754, learning_rate=0.001\n", + "Epoch 1751/2500 - loss=rnn_1step_loss=0.406185, rnn_1step_R2_maskV_-1.0=0.58064085, rnn_1step_CC_maskV_-1.0=0.76898497, rnn_1step_MSE_maskV_-1.0=0.40618503, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52333182, val_rnn_1step_R2_maskV_-1.0=0.4000808, val_rnn_1step_CC_maskV_-1.0=0.69311374, learning_rate=0.001\n", + "Epoch 2001/2500 - loss=rnn_1step_loss=0.40596297, rnn_1step_R2_maskV_-1.0=0.58091825, rnn_1step_CC_maskV_-1.0=0.76918405, rnn_1step_MSE_maskV_-1.0=0.405963, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52246147, val_rnn_1step_R2_maskV_-1.0=0.40110198, val_rnn_1step_CC_maskV_-1.0=0.69375587, learning_rate=0.001\n", + "Epoch 2251/2500 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40586039, rnn_1step_R2_maskV_-1.0=0.5810442, rnn_1step_CC_maskV_-1.0=0.76928163, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52172565, val_rnn_1step_R2_maskV_-1.0=0.40197471, val_rnn_1step_CC_maskV_-1.0=0.69428033, learning_rate=0.001\n", + "Epoch 2500/2500 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40565166, rnn_1step_R2_maskV_-1.0=0.58127201, rnn_1step_CC_maskV_-1.0=0.76943862, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52090472, val_rnn_1step_R2_maskV_-1.0=0.40296423, val_rnn_1step_CC_maskV_-1.0=0.69484705, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:31:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 215.69s\n", + "\u001b[32m2025-05-30 14:31:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:31:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 146 (stopped at 161 epochs).\n", + "\u001b[32m2025-05-30 14:31:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/162 - loss=rnn_1_1step_loss=0.99566752, rnn_1_1step_R2_maskV_-1.0=-0.018433746, rnn_1_1step_CC_maskV_-1.0=0.09382765, rnn_1_1step_MSE_maskV_-1.0=0.99566746, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.95804024, val_rnn_1_1step_R2_maskV_-1.0=-0.080078453, val_rnn_1_1step_CC_maskV_-1.0=0.19877422, learning_rate=0.001\n", + "Epoch 18/162 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.73360234, rnn_1_1step_R2_maskV_-1.0=0.24575938, rnn_1_1step_CC_maskV_-1.0=0.51854873, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.73478907, val_rnn_1_1step_R2_maskV_-1.0=0.1603319, val_rnn_1_1step_CC_maskV_-1.0=0.48872986, learning_rate=0.001\n", + "Epoch 35/162 - loss=rnn_1_1step_loss=0.54944777, rnn_1_1step_R2_maskV_-1.0=0.43599874, rnn_1_1step_CC_maskV_-1.0=0.66944873, rnn_1_1step_MSE_maskV_-1.0=0.54944783, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61080092, val_rnn_1_1step_R2_maskV_-1.0=0.30131233, val_rnn_1_1step_CC_maskV_-1.0=0.61315674, learning_rate=0.001\n", + "Epoch 52/162 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.50760198, rnn_1_1step_R2_maskV_-1.0=0.4777422, rnn_1_1step_CC_maskV_-1.0=0.69956231, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5913586, val_rnn_1_1step_R2_maskV_-1.0=0.32333806, val_rnn_1_1step_CC_maskV_-1.0=0.63421726, learning_rate=0.001\n", + "Epoch 69/162 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.49185905, rnn_1_1step_R2_maskV_-1.0=0.49345988, rnn_1_1step_CC_maskV_-1.0=0.71084845, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58668691, val_rnn_1_1step_R2_maskV_-1.0=0.32852554, val_rnn_1_1step_CC_maskV_-1.0=0.63798493, learning_rate=0.001\n", + "Epoch 86/162 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.47454605, rnn_1_1step_R2_maskV_-1.0=0.51120681, rnn_1_1step_CC_maskV_-1.0=0.72310907, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57771665, val_rnn_1_1step_R2_maskV_-1.0=0.33850831, val_rnn_1_1step_CC_maskV_-1.0=0.64558363, learning_rate=0.001\n", + "Epoch 103/162 - loss=rnn_1_1step_loss=0.44633785, rnn_1_1step_R2_maskV_-1.0=0.5399543, rnn_1_1step_CC_maskV_-1.0=0.74240464, rnn_1_1step_MSE_maskV_-1.0=0.44633782, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55470318, val_rnn_1_1step_R2_maskV_-1.0=0.36450806, val_rnn_1_1step_CC_maskV_-1.0=0.66529429, learning_rate=0.001\n", + "Epoch 120/162 - loss=rnn_1_1step_loss=0.43073082, rnn_1_1step_R2_maskV_-1.0=0.55560458, rnn_1_1step_CC_maskV_-1.0=0.75280631, rnn_1_1step_MSE_maskV_-1.0=0.43073079, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54104453, val_rnn_1_1step_R2_maskV_-1.0=0.37991571, val_rnn_1_1step_CC_maskV_-1.0=0.67764837, learning_rate=0.001\n", + "Epoch 137/162 - loss=rnn_1_1step_loss=0.4250094, rnn_1_1step_R2_maskV_-1.0=0.56140518, rnn_1_1step_CC_maskV_-1.0=0.75659066, rnn_1_1step_MSE_maskV_-1.0=0.42500943, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53838629, val_rnn_1_1step_R2_maskV_-1.0=0.38279524, val_rnn_1_1step_CC_maskV_-1.0=0.68063623, learning_rate=0.001\n", + "Epoch 154/162 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42183569, rnn_1_1step_R2_maskV_-1.0=0.56465971, rnn_1_1step_CC_maskV_-1.0=0.75868535, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53830564, val_rnn_1_1step_R2_maskV_-1.0=0.38276136, val_rnn_1_1step_CC_maskV_-1.0=0.68151414, learning_rate=0.001\n", + "Epoch 162/162 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42077461, rnn_1_1step_R2_maskV_-1.0=0.56574172, rnn_1_1step_CC_maskV_-1.0=0.75938433, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53838921, val_rnn_1_1step_R2_maskV_-1.0=0.38263279, val_rnn_1_1step_CC_maskV_-1.0=0.68173492, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:31:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.23s\n", + "\u001b[32m2025-05-30 14:31:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.52090472)\n", + "\u001b[32m2025-05-30 14:31:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.363, R2_maskV_-1.0=0.637, CC_maskV_-1.0=0.798\n", + "\u001b[32m2025-05-30 14:31:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.502, R2_maskV_-1.0=0.438, CC_maskV_-1.0=0.713\n", + "\u001b[32m2025-05-30 14:31:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 14:31:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:31:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 114 (stopped at 129 epochs).\n", + "\u001b[32m2025-05-30 14:31:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/130 - loss=594.25262, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0074141631, MSE_maskV_-1.0=592.50763, val_loss=38.839394, val_CC_maskV_-1.0=0.022778172, val_MSE_maskV_-1.0=38.387817, learning_rate=0.001\n", + "Epoch 14/130 - loss=2.1550989, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.077298798, MSE_maskV_-1.0=2.15781, val_loss=2.0897517, val_CC_maskV_-1.0=0.075835221, val_MSE_maskV_-1.0=2.0922527, learning_rate=0.001\n", + "Epoch 27/130 - loss=1.2459617, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.16555959, MSE_maskV_-1.0=1.2462595, val_loss=1.2455547, val_CC_maskV_-1.0=0.16491401, val_MSE_maskV_-1.0=1.2430674, learning_rate=0.001\n", + "Epoch 40/130 - loss=1.0340892, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.24704584, MSE_maskV_-1.0=1.0336785, val_loss=1.0393254, val_CC_maskV_-1.0=0.24768506, val_MSE_maskV_-1.0=1.0365541, learning_rate=0.001\n", + "Epoch 53/130 - loss=0.96305841, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.29683262, MSE_maskV_-1.0=0.96234602, val_loss=0.9749651, val_CC_maskV_-1.0=0.2898623, val_MSE_maskV_-1.0=0.97169971, learning_rate=0.001\n", + "Epoch 66/130 - loss=0.92012936, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.33180127, MSE_maskV_-1.0=0.91996646, val_loss=0.92263943, val_CC_maskV_-1.0=0.33159989, val_MSE_maskV_-1.0=0.9212417, learning_rate=0.001\n", + "Epoch 79/130 - loss=0.89687842, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35351115, MSE_maskV_-1.0=0.89726377, val_loss=0.88571411, val_CC_maskV_-1.0=0.36401555, val_MSE_maskV_-1.0=0.88408428, learning_rate=0.001\n", + "Epoch 92/130 - loss=0.87857068, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37122002, MSE_maskV_-1.0=0.87747359, val_loss=0.89092296, val_CC_maskV_-1.0=0.36989182, val_MSE_maskV_-1.0=0.88958305, learning_rate=0.001\n", + "Epoch 105/130 - loss=0.87092566, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38005096, MSE_maskV_-1.0=0.87037003, val_loss=0.88346928, val_CC_maskV_-1.0=0.3763344, val_MSE_maskV_-1.0=0.88109767, learning_rate=0.001\n", + "Epoch 118/130 - loss=0.85924035, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39174926, MSE_maskV_-1.0=0.85921586, val_loss=0.86705756, val_CC_maskV_-1.0=0.38794068, val_MSE_maskV_-1.0=0.866005, learning_rate=0.001\n", + "Epoch 130/130 - loss=0.8538307, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39792827, MSE_maskV_-1.0=0.85610271, val_loss=0.87082255, val_CC_maskV_-1.0=0.38925847, val_MSE_maskV_-1.0=0.87000042, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:31:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 31.79s\n", + "\u001b[32m2025-05-30 14:31:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:32:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 114 (stopped at 129 epochs).\n", + "\u001b[32m2025-05-30 14:32:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/130 - loss=333.02753, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=-0.014914022, MSE_maskV_-1.0=332.08023, val_loss=27.809048, val_CC_maskV_-1.0=-0.0085753119, val_MSE_maskV_-1.0=27.551493, learning_rate=0.001\n", + "Epoch 14/130 - loss=1.8239194, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.11520648, MSE_maskV_-1.0=1.8265387, val_loss=1.7824981, val_CC_maskV_-1.0=0.11480943, val_MSE_maskV_-1.0=1.7771305, learning_rate=0.001\n", + "Epoch 27/130 - loss=1.1766281, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.20211591, MSE_maskV_-1.0=1.177009, val_loss=1.1811079, val_CC_maskV_-1.0=0.19987755, val_MSE_maskV_-1.0=1.1745601, learning_rate=0.001\n", + "Epoch 40/130 - loss=1.0066894, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.27296764, MSE_maskV_-1.0=1.0063218, val_loss=1.0125407, val_CC_maskV_-1.0=0.27369872, val_MSE_maskV_-1.0=1.0081518, learning_rate=0.001\n", + "Epoch 53/130 - loss=0.95051473, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.31322816, MSE_maskV_-1.0=0.94982976, val_loss=0.96207207, val_CC_maskV_-1.0=0.30752832, val_MSE_maskV_-1.0=0.95775485, learning_rate=0.001\n", + "Epoch 66/130 - loss=0.91313279, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34221444, MSE_maskV_-1.0=0.91290623, val_loss=0.92004347, val_CC_maskV_-1.0=0.34067878, val_MSE_maskV_-1.0=0.91772294, learning_rate=0.001\n", + "Epoch 79/130 - loss=0.8945117, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35951746, MSE_maskV_-1.0=0.89485675, val_loss=0.885212, val_CC_maskV_-1.0=0.36922136, val_MSE_maskV_-1.0=0.88293773, learning_rate=0.001\n", + "Epoch 92/130 - loss=0.87706846, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37518322, MSE_maskV_-1.0=0.87596047, val_loss=0.89718711, val_CC_maskV_-1.0=0.37089968, val_MSE_maskV_-1.0=0.8951748, learning_rate=0.001\n", + "Epoch 105/130 - loss=0.87102854, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3821573, MSE_maskV_-1.0=0.87043184, val_loss=0.88900274, val_CC_maskV_-1.0=0.37445217, val_MSE_maskV_-1.0=0.88615352, learning_rate=0.001\n", + "Epoch 118/130 - loss=0.85998893, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39285919, MSE_maskV_-1.0=0.85998482, val_loss=0.87103003, val_CC_maskV_-1.0=0.38724241, val_MSE_maskV_-1.0=0.86941707, learning_rate=0.001\n", + "Epoch 130/130 - loss=0.85526717, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39857998, MSE_maskV_-1.0=0.85756385, val_loss=0.87340355, val_CC_maskV_-1.0=0.38999632, val_MSE_maskV_-1.0=0.8721379, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:32:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 30.59s\n", + "\u001b[32m2025-05-30 14:32:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.8459788)\n", + "\u001b[32m2025-05-30 14:32:26\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 711us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:32:26\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.842, R2_maskV_-1.0=0.158, CC_maskV_-1.0=0.407\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 742us/step\n", + "51/51 [==============================] - 0s 753us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:32:26\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_ErSV16\" (1/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 14:32:26\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_A1HL64U_ErSV16\" (2/16)\n", + "\u001b[32m2025-05-30 14:32:26\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_A1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 14:32:26\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 14:32:26\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 14:32:27\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 14:32:27\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 14:32:27\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 14:32:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:32:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 106 (stopped at 121 epochs).\n", + "\u001b[32m2025-05-30 14:32:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/122 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.9990198, rnn_1step_R2_maskV_-1.0=-0.021862552, rnn_1step_CC_maskV_-1.0=0.022567149, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96204519, val_rnn_1step_R2_maskV_-1.0=-0.085033074, val_rnn_1step_CC_maskV_-1.0=0.13221639, learning_rate=0.001\n", + "Epoch 14/122 - loss=rnn_1step_loss=0.77290583, rnn_1step_R2_maskV_-1.0=0.20478147, rnn_1step_CC_maskV_-1.0=0.48022139, rnn_1step_MSE_maskV_-1.0=0.77290589, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.76060438, val_rnn_1step_R2_maskV_-1.0=0.12849073, val_rnn_1step_CC_maskV_-1.0=0.46517119, learning_rate=0.001\n", + "Epoch 27/122 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.59862614, rnn_1step_R2_maskV_-1.0=0.38019222, rnn_1step_CC_maskV_-1.0=0.63324022, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64721799, val_rnn_1step_R2_maskV_-1.0=0.25887579, val_rnn_1step_CC_maskV_-1.0=0.57989073, learning_rate=0.001\n", + "Epoch 40/122 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.53546375, rnn_1step_R2_maskV_-1.0=0.44620746, rnn_1step_CC_maskV_-1.0=0.68009269, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62624824, val_rnn_1step_R2_maskV_-1.0=0.28339088, val_rnn_1step_CC_maskV_-1.0=0.60386729, learning_rate=0.001\n", + "Epoch 53/122 - loss=rnn_1step_loss=0.50212812, rnn_1step_R2_maskV_-1.0=0.48051417, rnn_1step_CC_maskV_-1.0=0.70420128, rnn_1step_MSE_maskV_-1.0=0.50212818, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61418772, val_rnn_1step_R2_maskV_-1.0=0.2970627, val_rnn_1step_CC_maskV_-1.0=0.61479795, learning_rate=0.001\n", + "Epoch 66/122 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.46567836, rnn_1step_R2_maskV_-1.0=0.51753455, rnn_1step_CC_maskV_-1.0=0.72975373, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59082705, val_rnn_1step_R2_maskV_-1.0=0.32348269, val_rnn_1step_CC_maskV_-1.0=0.63098788, learning_rate=0.001\n", + "Epoch 79/122 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.43166611, rnn_1step_R2_maskV_-1.0=0.55265832, rnn_1step_CC_maskV_-1.0=0.75235033, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57942629, val_rnn_1step_R2_maskV_-1.0=0.33477083, val_rnn_1step_CC_maskV_-1.0=0.64140958, learning_rate=0.001\n", + "Epoch 92/122 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40909648, rnn_1step_R2_maskV_-1.0=0.57587242, rnn_1step_CC_maskV_-1.0=0.76800108, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5607518, val_rnn_1step_R2_maskV_-1.0=0.35608596, val_rnn_1step_CC_maskV_-1.0=0.65455508, learning_rate=0.001\n", + "Epoch 105/122 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39861962, rnn_1step_R2_maskV_-1.0=0.58650815, rnn_1step_CC_maskV_-1.0=0.77513993, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56207401, val_rnn_1step_R2_maskV_-1.0=0.35372883, val_rnn_1step_CC_maskV_-1.0=0.65643358, learning_rate=0.001\n", + "Epoch 118/122 - loss=rnn_1step_loss=0.38994393, rnn_1step_R2_maskV_-1.0=0.59481573, rnn_1step_CC_maskV_-1.0=0.77964967, rnn_1step_MSE_maskV_-1.0=0.3899439, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54757452, val_rnn_1step_R2_maskV_-1.0=0.37122887, val_rnn_1step_CC_maskV_-1.0=0.66786075, learning_rate=0.001\n", + "Epoch 122/122 - loss=rnn_1step_loss=0.38510415, rnn_1step_R2_maskV_-1.0=0.60004306, rnn_1step_CC_maskV_-1.0=0.78261161, rnn_1step_MSE_maskV_-1.0=0.38510418, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54062241, val_rnn_1step_R2_maskV_-1.0=0.3793374, val_rnn_1step_CC_maskV_-1.0=0.67035866, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:32:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.47s\n", + "\u001b[32m2025-05-30 14:32:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:33:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 191 (stopped at 206 epochs).\n", + "\u001b[32m2025-05-30 14:33:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/207 - loss=rnn_1_1step_loss=0.99986488, rnn_1_1step_R2_maskV_-1.0=-0.022880677, rnn_1_1step_CC_maskV_-1.0=-0.00070494227, rnn_1_1step_MSE_maskV_-1.0=0.99986494, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96219414, val_rnn_1_1step_R2_maskV_-1.0=-0.084769115, val_rnn_1_1step_CC_maskV_-1.0=0.14582865, learning_rate=0.001\n", + "Epoch 22/207 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.62931275, rnn_1_1step_R2_maskV_-1.0=0.3477779, rnn_1_1step_CC_maskV_-1.0=0.60974139, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.66945523, val_rnn_1_1step_R2_maskV_-1.0=0.23772699, val_rnn_1_1step_CC_maskV_-1.0=0.56514198, learning_rate=0.001\n", + "Epoch 43/207 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.5199163, rnn_1_1step_R2_maskV_-1.0=0.46184307, rnn_1_1step_CC_maskV_-1.0=0.69222432, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6260612, val_rnn_1_1step_R2_maskV_-1.0=0.28664535, val_rnn_1_1step_CC_maskV_-1.0=0.5989213, learning_rate=0.001\n", + "Epoch 64/207 - loss=rnn_1_1step_loss=0.45161095, rnn_1_1step_R2_maskV_-1.0=0.53157616, rnn_1_1step_CC_maskV_-1.0=0.73981917, rnn_1_1step_MSE_maskV_-1.0=0.45161098, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59387261, val_rnn_1_1step_R2_maskV_-1.0=0.31988102, val_rnn_1_1step_CC_maskV_-1.0=0.6275056, learning_rate=0.001\n", + "Epoch 85/207 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42728522, rnn_1_1step_R2_maskV_-1.0=0.55614096, rnn_1_1step_CC_maskV_-1.0=0.75574529, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58286875, val_rnn_1_1step_R2_maskV_-1.0=0.33131129, val_rnn_1_1step_CC_maskV_-1.0=0.64014298, learning_rate=0.001\n", + "Epoch 106/207 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39724812, rnn_1_1step_R2_maskV_-1.0=0.58756328, rnn_1_1step_CC_maskV_-1.0=0.77549636, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56500739, val_rnn_1_1step_R2_maskV_-1.0=0.35176468, val_rnn_1_1step_CC_maskV_-1.0=0.652511, learning_rate=0.001\n", + "Epoch 127/207 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39578703, rnn_1_1step_R2_maskV_-1.0=0.58940077, rnn_1_1step_CC_maskV_-1.0=0.77634281, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54235834, val_rnn_1_1step_R2_maskV_-1.0=0.38000894, val_rnn_1_1step_CC_maskV_-1.0=0.66250604, learning_rate=0.001\n", + "Epoch 148/207 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38068008, rnn_1_1step_R2_maskV_-1.0=0.60455251, rnn_1_1step_CC_maskV_-1.0=0.78712261, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56293267, val_rnn_1_1step_R2_maskV_-1.0=0.35503572, val_rnn_1_1step_CC_maskV_-1.0=0.66005927, learning_rate=0.001\n", + "Epoch 169/207 - loss=rnn_1_1step_loss=0.35687438, rnn_1_1step_R2_maskV_-1.0=0.6298461, rnn_1_1step_CC_maskV_-1.0=0.80112922, rnn_1_1step_MSE_maskV_-1.0=0.35687441, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55044276, val_rnn_1_1step_R2_maskV_-1.0=0.36966777, val_rnn_1_1step_CC_maskV_-1.0=0.67248785, learning_rate=0.001\n", + "Epoch 190/207 - loss=rnn_1_1step_loss=0.3441321, rnn_1_1step_R2_maskV_-1.0=0.64316738, rnn_1_1step_CC_maskV_-1.0=0.80899715, rnn_1_1step_MSE_maskV_-1.0=0.34413213, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54428244, val_rnn_1_1step_R2_maskV_-1.0=0.37474969, val_rnn_1_1step_CC_maskV_-1.0=0.6748758, learning_rate=0.001\n", + "Epoch 207/207 - loss=rnn_1_1step_loss=0.34830752, rnn_1_1step_R2_maskV_-1.0=0.63877511, rnn_1_1step_CC_maskV_-1.0=0.80802912, rnn_1_1step_MSE_maskV_-1.0=0.34830755, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54437238, val_rnn_1_1step_R2_maskV_-1.0=0.37471631, val_rnn_1_1step_CC_maskV_-1.0=0.67372739, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:33:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 26.18s\n", + "\u001b[32m2025-05-30 14:33:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.51022452)\n", + "\u001b[32m2025-05-30 14:33:09\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.302, R2_maskV_-1.0=0.698, CC_maskV_-1.0=0.836\n", + "\u001b[32m2025-05-30 14:33:09\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.478, R2_maskV_-1.0=0.468, CC_maskV_-1.0=0.72\n", + "\u001b[32m2025-05-30 14:33:09\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 14:33:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:33:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 144 (stopped at 159 epochs).\n", + "\u001b[32m2025-05-30 14:33:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/160 - loss=2.8143654, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.012209926, MSE_maskV_-1.0=2.8122027, val_loss=1.3788799, val_CC_maskV_-1.0=0.049356729, val_MSE_maskV_-1.0=1.3718739, learning_rate=0.001\n", + "Epoch 17/160 - loss=0.80709267, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43942416, MSE_maskV_-1.0=0.80677021, val_loss=0.81004798, val_CC_maskV_-1.0=0.43935296, val_MSE_maskV_-1.0=0.80951488, learning_rate=0.001\n", + "Epoch 33/160 - loss=0.77340961, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47499043, MSE_maskV_-1.0=0.77320021, val_loss=0.77690619, val_CC_maskV_-1.0=0.47250107, val_MSE_maskV_-1.0=0.77715445, learning_rate=0.001\n", + "Epoch 49/160 - loss=0.7593742, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48991725, MSE_maskV_-1.0=0.75922024, val_loss=0.76243228, val_CC_maskV_-1.0=0.48589724, val_MSE_maskV_-1.0=0.76305097, learning_rate=0.001\n", + "Epoch 65/160 - loss=0.75207222, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49678764, MSE_maskV_-1.0=0.75210035, val_loss=0.75471574, val_CC_maskV_-1.0=0.49038404, val_MSE_maskV_-1.0=0.75609636, learning_rate=0.001\n", + "Epoch 81/160 - loss=0.74808443, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5012514, MSE_maskV_-1.0=0.74804884, val_loss=0.75137013, val_CC_maskV_-1.0=0.49575236, val_MSE_maskV_-1.0=0.75228649, learning_rate=0.001\n", + "Epoch 97/160 - loss=0.74592108, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50303924, MSE_maskV_-1.0=0.7451371, val_loss=0.74528372, val_CC_maskV_-1.0=0.50204051, val_MSE_maskV_-1.0=0.74574965, learning_rate=0.001\n", + "Epoch 113/160 - loss=0.74407822, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50489026, MSE_maskV_-1.0=0.74649495, val_loss=0.74484724, val_CC_maskV_-1.0=0.50265568, val_MSE_maskV_-1.0=0.74544883, learning_rate=0.001\n", + "Epoch 129/160 - loss=0.7433641, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50588471, MSE_maskV_-1.0=0.74295342, val_loss=0.74309212, val_CC_maskV_-1.0=0.50326741, val_MSE_maskV_-1.0=0.74402207, learning_rate=0.001\n", + "Epoch 145/160 - loss=0.74321586, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50539929, MSE_maskV_-1.0=0.74341464, val_loss=0.74286395, val_CC_maskV_-1.0=0.50485945, val_MSE_maskV_-1.0=0.74302417, learning_rate=0.001\n", + "Epoch 160/160 - loss=0.74252957, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50548494, MSE_maskV_-1.0=0.74231732, val_loss=0.74423671, val_CC_maskV_-1.0=0.50279731, val_MSE_maskV_-1.0=0.74478918, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:33:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 38.24s\n", + "\u001b[32m2025-05-30 14:33:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:34:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 144 (stopped at 159 epochs).\n", + "\u001b[32m2025-05-30 14:34:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/160 - loss=3.1221735, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.038547255, MSE_maskV_-1.0=3.1195283, val_loss=1.4107467, val_CC_maskV_-1.0=0.072465159, val_MSE_maskV_-1.0=1.4039701, learning_rate=0.001\n", + "Epoch 17/160 - loss=0.8061443, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44038525, MSE_maskV_-1.0=0.80585766, val_loss=0.80777627, val_CC_maskV_-1.0=0.44054541, val_MSE_maskV_-1.0=0.80736345, learning_rate=0.001\n", + "Epoch 33/160 - loss=0.77276134, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47561938, MSE_maskV_-1.0=0.77252609, val_loss=0.77580273, val_CC_maskV_-1.0=0.47277015, val_MSE_maskV_-1.0=0.77617413, learning_rate=0.001\n", + "Epoch 49/160 - loss=0.75898856, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49029183, MSE_maskV_-1.0=0.75882095, val_loss=0.76115686, val_CC_maskV_-1.0=0.48646167, val_MSE_maskV_-1.0=0.76189405, learning_rate=0.001\n", + "Epoch 65/160 - loss=0.7518608, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49697801, MSE_maskV_-1.0=0.75188178, val_loss=0.75404346, val_CC_maskV_-1.0=0.49047646, val_MSE_maskV_-1.0=0.75552487, learning_rate=0.001\n", + "Epoch 81/160 - loss=0.74796772, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50133294, MSE_maskV_-1.0=0.74793649, val_loss=0.75078422, val_CC_maskV_-1.0=0.49594831, val_MSE_maskV_-1.0=0.75174731, learning_rate=0.001\n", + "Epoch 97/160 - loss=0.74582779, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50311881, MSE_maskV_-1.0=0.74503404, val_loss=0.74484664, val_CC_maskV_-1.0=0.50211704, val_MSE_maskV_-1.0=0.74534875, learning_rate=0.001\n", + "Epoch 113/160 - loss=0.74404526, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50491261, MSE_maskV_-1.0=0.74645174, val_loss=0.74451458, val_CC_maskV_-1.0=0.50275153, val_MSE_maskV_-1.0=0.7451278, learning_rate=0.001\n", + "Epoch 129/160 - loss=0.7433303, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50590563, MSE_maskV_-1.0=0.74291933, val_loss=0.74273992, val_CC_maskV_-1.0=0.50345284, val_MSE_maskV_-1.0=0.74367195, learning_rate=0.001\n", + "Epoch 145/160 - loss=0.74319917, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50541598, MSE_maskV_-1.0=0.74339855, val_loss=0.74258792, val_CC_maskV_-1.0=0.50499713, val_MSE_maskV_-1.0=0.74274832, learning_rate=0.001\n", + "Epoch 160/160 - loss=0.74252123, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50549418, MSE_maskV_-1.0=0.74230868, val_loss=0.7439881, val_CC_maskV_-1.0=0.50293022, val_MSE_maskV_-1.0=0.74454236, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:34:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 38.35s\n", + "\u001b[32m2025-05-30 14:34:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.74078238)\n", + "\u001b[32m2025-05-30 14:34:26\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 732us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:34:26\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.741, R2_maskV_-1.0=0.26, CC_maskV_-1.0=0.509\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 739us/step\n", + "51/51 [==============================] - 0s 752us/step\n", + "84/84 [==============================] - 0s 720us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:34:27\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_A1HL64U_ErSV16\" (2/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_A1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 14:34:27\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_K1HL64U_ErSV16\" (3/16)\n", + "\u001b[32m2025-05-30 14:34:27\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_K1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 14:34:27\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 14:34:27\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 14:34:27\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 14:34:27\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 14:34:27\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 14:34:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:34:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 71 (stopped at 86 epochs).\n", + "\u001b[32m2025-05-30 14:34:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/87 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.99862367, rnn_1step_R2_maskV_-1.0=-0.021552235, rnn_1step_CC_maskV_-1.0=0.098708227, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96493703, val_rnn_1step_R2_maskV_-1.0=-0.087711096, val_rnn_1step_CC_maskV_-1.0=0.11625089, learning_rate=0.001\n", + "Epoch 10/87 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.86153406, rnn_1step_R2_maskV_-1.0=0.11667891, rnn_1step_CC_maskV_-1.0=0.39760053, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.85391808, val_rnn_1step_R2_maskV_-1.0=0.029775962, val_rnn_1step_CC_maskV_-1.0=0.34253979, learning_rate=0.001\n", + "Epoch 19/87 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.64883822, rnn_1step_R2_maskV_-1.0=0.32483321, rnn_1step_CC_maskV_-1.0=0.5931679, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.69483536, val_rnn_1step_R2_maskV_-1.0=0.20876512, val_rnn_1step_CC_maskV_-1.0=0.53787786, learning_rate=0.001\n", + "Epoch 28/87 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.55565554, rnn_1step_R2_maskV_-1.0=0.42235249, rnn_1step_CC_maskV_-1.0=0.66625446, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64463919, val_rnn_1step_R2_maskV_-1.0=0.2671659, val_rnn_1step_CC_maskV_-1.0=0.58333212, learning_rate=0.001\n", + "Epoch 37/87 - loss=rnn_1step_loss=0.48013678, rnn_1step_R2_maskV_-1.0=0.50200832, rnn_1step_CC_maskV_-1.0=0.71984696, rnn_1step_MSE_maskV_-1.0=0.48013681, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60088211, val_rnn_1step_R2_maskV_-1.0=0.3192282, val_rnn_1step_CC_maskV_-1.0=0.6222434, learning_rate=0.001\n", + "Epoch 46/87 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40173188, rnn_1step_R2_maskV_-1.0=0.58470857, rnn_1step_CC_maskV_-1.0=0.77223432, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53660828, val_rnn_1step_R2_maskV_-1.0=0.39001444, val_rnn_1step_CC_maskV_-1.0=0.67368507, learning_rate=0.001\n", + "Epoch 55/87 - loss=rnn_1step_loss=0.35444424, rnn_1step_R2_maskV_-1.0=0.63413525, rnn_1step_CC_maskV_-1.0=0.80236399, rnn_1step_MSE_maskV_-1.0=0.35444421, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50640559, val_rnn_1step_R2_maskV_-1.0=0.42333671, val_rnn_1step_CC_maskV_-1.0=0.69606102, learning_rate=0.001\n", + "Epoch 64/87 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31596783, rnn_1step_R2_maskV_-1.0=0.67393064, rnn_1step_CC_maskV_-1.0=0.82608545, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48635349, val_rnn_1step_R2_maskV_-1.0=0.44608614, val_rnn_1step_CC_maskV_-1.0=0.71207184, learning_rate=0.001\n", + "Epoch 73/87 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.28282699, rnn_1step_R2_maskV_-1.0=0.70783859, rnn_1step_CC_maskV_-1.0=0.84591454, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47863421, val_rnn_1step_R2_maskV_-1.0=0.45457029, val_rnn_1step_CC_maskV_-1.0=0.72152263, learning_rate=0.001\n", + "Epoch 82/87 - loss=rnn_1step_loss=0.26574591, rnn_1step_R2_maskV_-1.0=0.72524738, rnn_1step_CC_maskV_-1.0=0.85596538, rnn_1step_MSE_maskV_-1.0=0.26574588, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48600021, val_rnn_1step_R2_maskV_-1.0=0.44596595, val_rnn_1step_CC_maskV_-1.0=0.71986252, learning_rate=0.001\n", + "Epoch 87/87 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.26048574, rnn_1step_R2_maskV_-1.0=0.73070443, rnn_1step_CC_maskV_-1.0=0.85916966, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49299121, val_rnn_1step_R2_maskV_-1.0=0.43772578, val_rnn_1step_CC_maskV_-1.0=0.71658796, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:34:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 9.87s\n", + "\u001b[32m2025-05-30 14:34:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:34:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 76 (stopped at 91 epochs).\n", + "\u001b[32m2025-05-30 14:34:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.99909097, rnn_1_1step_R2_maskV_-1.0=-0.022013925, rnn_1_1step_CC_maskV_-1.0=0.050214879, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96463013, val_rnn_1_1step_R2_maskV_-1.0=-0.087362841, val_rnn_1_1step_CC_maskV_-1.0=0.22143725, learning_rate=0.001\n", + "Epoch 11/92 - loss=rnn_1_1step_loss=0.82092828, rnn_1_1step_R2_maskV_-1.0=0.15777263, rnn_1_1step_CC_maskV_-1.0=0.4433794, rnn_1_1step_MSE_maskV_-1.0=0.82092822, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.80359381, val_rnn_1_1step_R2_maskV_-1.0=0.087744325, val_rnn_1_1step_CC_maskV_-1.0=0.4222708, learning_rate=0.001\n", + "Epoch 21/92 - loss=rnn_1_1step_loss=0.62866312, rnn_1_1step_R2_maskV_-1.0=0.34829366, rnn_1_1step_CC_maskV_-1.0=0.61097705, rnn_1_1step_MSE_maskV_-1.0=0.62866318, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.67701715, val_rnn_1_1step_R2_maskV_-1.0=0.22745979, val_rnn_1_1step_CC_maskV_-1.0=0.55640244, learning_rate=0.001\n", + "Epoch 31/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.5260362, rnn_1_1step_R2_maskV_-1.0=0.45431781, rnn_1_1step_CC_maskV_-1.0=0.68852663, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6317364, val_rnn_1_1step_R2_maskV_-1.0=0.27874139, val_rnn_1_1step_CC_maskV_-1.0=0.59738129, learning_rate=0.001\n", + "Epoch 41/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.43872133, rnn_1_1step_R2_maskV_-1.0=0.54634893, rnn_1_1step_CC_maskV_-1.0=0.74843645, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57515895, val_rnn_1_1step_R2_maskV_-1.0=0.34528536, val_rnn_1_1step_CC_maskV_-1.0=0.64244765, learning_rate=0.001\n", + "Epoch 51/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36824515, rnn_1_1step_R2_maskV_-1.0=0.62066364, rnn_1_1step_CC_maskV_-1.0=0.79410625, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5144527, val_rnn_1_1step_R2_maskV_-1.0=0.4129144, val_rnn_1_1step_CC_maskV_-1.0=0.68846142, learning_rate=0.001\n", + "Epoch 61/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32787389, rnn_1_1step_R2_maskV_-1.0=0.66265565, rnn_1_1step_CC_maskV_-1.0=0.8191725, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49635807, val_rnn_1_1step_R2_maskV_-1.0=0.43341607, val_rnn_1_1step_CC_maskV_-1.0=0.70291787, learning_rate=0.001\n", + "Epoch 71/92 - loss=rnn_1_1step_loss=0.28953838, rnn_1_1step_R2_maskV_-1.0=0.70202291, rnn_1_1step_CC_maskV_-1.0=0.84222156, rnn_1_1step_MSE_maskV_-1.0=0.28953835, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48256811, val_rnn_1_1step_R2_maskV_-1.0=0.44902346, val_rnn_1_1step_CC_maskV_-1.0=0.71535176, learning_rate=0.001\n", + "Epoch 81/92 - loss=rnn_1_1step_loss=0.26168713, rnn_1_1step_R2_maskV_-1.0=0.73021579, rnn_1_1step_CC_maskV_-1.0=0.85837424, rnn_1_1step_MSE_maskV_-1.0=0.26168716, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48098445, val_rnn_1_1step_R2_maskV_-1.0=0.45007017, val_rnn_1_1step_CC_maskV_-1.0=0.71871275, learning_rate=0.001\n", + "Epoch 91/92 - loss=rnn_1_1step_loss=0.2468289, rnn_1_1step_R2_maskV_-1.0=0.74521184, rnn_1_1step_CC_maskV_-1.0=0.86689299, rnn_1_1step_MSE_maskV_-1.0=0.24682891, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4837428, val_rnn_1_1step_R2_maskV_-1.0=0.44633427, val_rnn_1_1step_CC_maskV_-1.0=0.71720821, learning_rate=0.001\n", + "Epoch 92/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.24568661, rnn_1_1step_R2_maskV_-1.0=0.7463733, rnn_1_1step_CC_maskV_-1.0=0.86755466, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48383859, val_rnn_1_1step_R2_maskV_-1.0=0.44621167, val_rnn_1_1step_CC_maskV_-1.0=0.71715319, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:34:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.21s\n", + "\u001b[32m2025-05-30 14:34:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.4782505)\n", + "\u001b[32m2025-05-30 14:34:48\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.248, R2_maskV_-1.0=0.752, CC_maskV_-1.0=0.867\n", + "\u001b[32m2025-05-30 14:34:49\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.445, R2_maskV_-1.0=0.508, CC_maskV_-1.0=0.747\n", + "\u001b[32m2025-05-30 14:34:49\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 14:34:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:36:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 357 (stopped at 372 epochs).\n", + "\u001b[32m2025-05-30 14:36:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/373 - loss=1.6185277, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.038789988, MSE_maskV_-1.0=1.6186672, val_loss=1.052887, val_CC_maskV_-1.0=0.087427698, val_MSE_maskV_-1.0=1.0509188, learning_rate=0.001\n", + "Epoch 39/373 - loss=0.90128738, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.32116675, MSE_maskV_-1.0=0.90194553, val_loss=0.90754688, val_CC_maskV_-1.0=0.32981017, val_MSE_maskV_-1.0=0.90549803, learning_rate=0.001\n", + "Epoch 77/373 - loss=0.87090456, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37028736, MSE_maskV_-1.0=0.87023455, val_loss=0.87799495, val_CC_maskV_-1.0=0.37640673, val_MSE_maskV_-1.0=0.87552494, learning_rate=0.001\n", + "Epoch 115/373 - loss=0.85341609, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39210242, MSE_maskV_-1.0=0.85308754, val_loss=0.86225718, val_CC_maskV_-1.0=0.39289078, val_MSE_maskV_-1.0=0.86060041, learning_rate=0.001\n", + "Epoch 153/373 - loss=0.8416779, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40582478, MSE_maskV_-1.0=0.84095097, val_loss=0.84858334, val_CC_maskV_-1.0=0.40839338, val_MSE_maskV_-1.0=0.84606618, learning_rate=0.001\n", + "Epoch 191/373 - loss=0.83367807, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41324157, MSE_maskV_-1.0=0.83399659, val_loss=0.84053069, val_CC_maskV_-1.0=0.41532281, val_MSE_maskV_-1.0=0.83824843, learning_rate=0.001\n", + "Epoch 229/373 - loss=0.82745606, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41994965, MSE_maskV_-1.0=0.82652283, val_loss=0.83444327, val_CC_maskV_-1.0=0.4219594, val_MSE_maskV_-1.0=0.83177102, learning_rate=0.001\n", + "Epoch 267/373 - loss=0.82276535, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42471582, MSE_maskV_-1.0=0.82238102, val_loss=0.82879269, val_CC_maskV_-1.0=0.42659438, val_MSE_maskV_-1.0=0.82641286, learning_rate=0.001\n", + "Epoch 305/373 - loss=0.81883103, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42867488, MSE_maskV_-1.0=0.81946683, val_loss=0.82768279, val_CC_maskV_-1.0=0.42817318, val_MSE_maskV_-1.0=0.82477951, learning_rate=0.001\n", + "Epoch 343/373 - loss=0.81546116, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43220109, MSE_maskV_-1.0=0.81492752, val_loss=0.8227796, val_CC_maskV_-1.0=0.43283555, val_MSE_maskV_-1.0=0.82004219, learning_rate=0.001\n", + "Epoch 373/373 - loss=0.81355971, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43438101, MSE_maskV_-1.0=0.81311351, val_loss=0.82069361, val_CC_maskV_-1.0=0.43474221, val_MSE_maskV_-1.0=0.81827724, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:36:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 87.74s\n", + "\u001b[32m2025-05-30 14:36:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:37:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 357 (stopped at 372 epochs).\n", + "\u001b[32m2025-05-30 14:37:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/373 - loss=1.5775142, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.056642462, MSE_maskV_-1.0=1.578089, val_loss=1.0702622, val_CC_maskV_-1.0=0.084600493, val_MSE_maskV_-1.0=1.0668395, learning_rate=0.001\n", + "Epoch 39/373 - loss=0.90342414, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.31701419, MSE_maskV_-1.0=0.90409982, val_loss=0.91089165, val_CC_maskV_-1.0=0.32376513, val_MSE_maskV_-1.0=0.90863681, learning_rate=0.001\n", + "Epoch 77/373 - loss=0.87239826, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36792478, MSE_maskV_-1.0=0.87171483, val_loss=0.88030934, val_CC_maskV_-1.0=0.37308133, val_MSE_maskV_-1.0=0.87771583, learning_rate=0.001\n", + "Epoch 115/373 - loss=0.85455585, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39038631, MSE_maskV_-1.0=0.85426819, val_loss=0.86405051, val_CC_maskV_-1.0=0.39065033, val_MSE_maskV_-1.0=0.86231416, learning_rate=0.001\n", + "Epoch 153/373 - loss=0.84258014, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40468392, MSE_maskV_-1.0=0.8418467, val_loss=0.849922, val_CC_maskV_-1.0=0.40699738, val_MSE_maskV_-1.0=0.84733015, learning_rate=0.001\n", + "Epoch 191/373 - loss=0.83442056, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41232276, MSE_maskV_-1.0=0.8347345, val_loss=0.84162605, val_CC_maskV_-1.0=0.41422036, val_MSE_maskV_-1.0=0.83929229, learning_rate=0.001\n", + "Epoch 229/373 - loss=0.82807946, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41924506, MSE_maskV_-1.0=0.82714599, val_loss=0.83539248, val_CC_maskV_-1.0=0.42103544, val_MSE_maskV_-1.0=0.83268243, learning_rate=0.001\n", + "Epoch 267/373 - loss=0.82327133, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42415535, MSE_maskV_-1.0=0.82289356, val_loss=0.82956725, val_CC_maskV_-1.0=0.42590156, val_MSE_maskV_-1.0=0.82715017, learning_rate=0.001\n", + "Epoch 305/373 - loss=0.81925422, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42820653, MSE_maskV_-1.0=0.81988961, val_loss=0.82838404, val_CC_maskV_-1.0=0.4275673, val_MSE_maskV_-1.0=0.82545233, learning_rate=0.001\n", + "Epoch 343/373 - loss=0.81581205, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4318426, MSE_maskV_-1.0=0.81528103, val_loss=0.82332003, val_CC_maskV_-1.0=0.43241534, val_MSE_maskV_-1.0=0.82054144, learning_rate=0.001\n", + "Epoch 373/373 - loss=0.81385911, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43409202, MSE_maskV_-1.0=0.81340331, val_loss=0.82123947, val_CC_maskV_-1.0=0.43430725, val_MSE_maskV_-1.0=0.81878895, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:37:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 83.55s\n", + "\u001b[32m2025-05-30 14:37:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.82046139)\n", + "\u001b[32m2025-05-30 14:37:40\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 705us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:37:40\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.813, R2_maskV_-1.0=0.187, CC_maskV_-1.0=0.435\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 735us/step\n", + "51/51 [==============================] - 0s 718us/step\n", + "84/84 [==============================] - 0s 682us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:37:41\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_K1HL64U_ErSV16\" (3/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_K1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 14:37:41\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_Cz1HL64U_ErSV16\" (4/16)\n", + "\u001b[32m2025-05-30 14:37:41\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_Cz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 14:37:41\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 14:37:41\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 14:37:41\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 14:37:41\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 14:37:41\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 14:37:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:38:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 259 (stopped at 274 epochs).\n", + "\u001b[32m2025-05-30 14:38:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/275 - loss=rnn_1step_loss=0.99894094, rnn_1step_R2_maskV_-1.0=-0.021851629, rnn_1step_CC_maskV_-1.0=0.079279058, rnn_1step_MSE_maskV_-1.0=0.998941, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96367663, val_rnn_1step_R2_maskV_-1.0=-0.086236879, val_rnn_1step_CC_maskV_-1.0=0.28369886, learning_rate=0.001\n", + "Epoch 29/275 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.55344868, rnn_1step_R2_maskV_-1.0=0.42807955, rnn_1step_CC_maskV_-1.0=0.66694278, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62904102, val_rnn_1step_R2_maskV_-1.0=0.28370535, val_rnn_1step_CC_maskV_-1.0=0.60024273, learning_rate=0.001\n", + "Epoch 57/275 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.44021395, rnn_1step_R2_maskV_-1.0=0.54449886, rnn_1step_CC_maskV_-1.0=0.7466076, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55522865, val_rnn_1step_R2_maskV_-1.0=0.36106035, val_rnn_1step_CC_maskV_-1.0=0.66366947, learning_rate=0.001\n", + "Epoch 85/275 - loss=rnn_1step_loss=0.4082458, rnn_1step_R2_maskV_-1.0=0.5772357, rnn_1step_CC_maskV_-1.0=0.76805294, rnn_1step_MSE_maskV_-1.0=0.40824577, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54712373, val_rnn_1step_R2_maskV_-1.0=0.37042683, val_rnn_1step_CC_maskV_-1.0=0.66969782, learning_rate=0.001\n", + "Epoch 113/275 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38617018, rnn_1step_R2_maskV_-1.0=0.60010409, rnn_1step_CC_maskV_-1.0=0.78238893, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53954321, val_rnn_1step_R2_maskV_-1.0=0.37945002, val_rnn_1step_CC_maskV_-1.0=0.67842621, learning_rate=0.001\n", + "Epoch 141/275 - loss=rnn_1step_loss=0.36551729, rnn_1step_R2_maskV_-1.0=0.62182701, rnn_1step_CC_maskV_-1.0=0.79542595, rnn_1step_MSE_maskV_-1.0=0.36551732, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52292031, val_rnn_1step_R2_maskV_-1.0=0.39879709, val_rnn_1step_CC_maskV_-1.0=0.69320905, learning_rate=0.001\n", + "Epoch 169/275 - loss=rnn_1step_loss=0.35192895, rnn_1step_R2_maskV_-1.0=0.63598442, rnn_1step_CC_maskV_-1.0=0.80381608, rnn_1step_MSE_maskV_-1.0=0.35192898, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51137316, val_rnn_1step_R2_maskV_-1.0=0.41188753, val_rnn_1step_CC_maskV_-1.0=0.70317233, learning_rate=0.001\n", + "Epoch 197/275 - loss=rnn_1step_loss=0.34338889, rnn_1step_R2_maskV_-1.0=0.64472532, rnn_1step_CC_maskV_-1.0=0.80905694, rnn_1step_MSE_maskV_-1.0=0.34338886, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50414407, val_rnn_1step_R2_maskV_-1.0=0.42009929, val_rnn_1step_CC_maskV_-1.0=0.70860857, learning_rate=0.001\n", + "Epoch 225/275 - loss=rnn_1step_loss=0.33620605, rnn_1step_R2_maskV_-1.0=0.65210402, rnn_1step_CC_maskV_-1.0=0.81347495, rnn_1step_MSE_maskV_-1.0=0.33620608, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49964392, val_rnn_1step_R2_maskV_-1.0=0.42538962, val_rnn_1step_CC_maskV_-1.0=0.7118535, learning_rate=0.001\n", + "Epoch 253/275 - loss=rnn_1step_loss=0.32947418, rnn_1step_R2_maskV_-1.0=0.65906346, rnn_1step_CC_maskV_-1.0=0.81763721, rnn_1step_MSE_maskV_-1.0=0.32947415, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49904862, val_rnn_1step_R2_maskV_-1.0=0.42630088, val_rnn_1step_CC_maskV_-1.0=0.71296656, learning_rate=0.001\n", + "Epoch 275/275 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32458785, rnn_1step_R2_maskV_-1.0=0.6641562, rnn_1step_CC_maskV_-1.0=0.82067245, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49820051, val_rnn_1step_R2_maskV_-1.0=0.42745331, val_rnn_1step_CC_maskV_-1.0=0.71396595, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:38:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 26.95s\n", + "\u001b[32m2025-05-30 14:38:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:38:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 361 (stopped at 376 epochs).\n", + "\u001b[32m2025-05-30 14:38:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/377 - loss=rnn_1_1step_loss=0.99888152, rnn_1_1step_R2_maskV_-1.0=-0.021780111, rnn_1_1step_CC_maskV_-1.0=0.092300296, rnn_1_1step_MSE_maskV_-1.0=0.99888146, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96477717, val_rnn_1_1step_R2_maskV_-1.0=-0.087511688, val_rnn_1_1step_CC_maskV_-1.0=0.2522288, learning_rate=0.001\n", + "Epoch 39/377 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.51478213, rnn_1_1step_R2_maskV_-1.0=0.46741396, rnn_1_1step_CC_maskV_-1.0=0.69521093, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61962742, val_rnn_1_1step_R2_maskV_-1.0=0.29335067, val_rnn_1_1step_CC_maskV_-1.0=0.61058551, learning_rate=0.001\n", + "Epoch 77/377 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42089215, rnn_1_1step_R2_maskV_-1.0=0.56390941, rnn_1_1step_CC_maskV_-1.0=0.75972998, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55477637, val_rnn_1_1step_R2_maskV_-1.0=0.36236835, val_rnn_1_1step_CC_maskV_-1.0=0.66377151, learning_rate=0.001\n", + "Epoch 115/377 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39713335, rnn_1_1step_R2_maskV_-1.0=0.5883348, rnn_1_1step_CC_maskV_-1.0=0.7754792, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54631454, val_rnn_1_1step_R2_maskV_-1.0=0.37205672, val_rnn_1_1step_CC_maskV_-1.0=0.67143166, learning_rate=0.001\n", + "Epoch 153/377 - loss=rnn_1_1step_loss=0.37762198, rnn_1_1step_R2_maskV_-1.0=0.6086154, rnn_1_1step_CC_maskV_-1.0=0.78811097, rnn_1_1step_MSE_maskV_-1.0=0.37762195, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53408164, val_rnn_1_1step_R2_maskV_-1.0=0.38590908, val_rnn_1_1step_CC_maskV_-1.0=0.68237948, learning_rate=0.001\n", + "Epoch 191/377 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.35716939, rnn_1_1step_R2_maskV_-1.0=0.62993431, rnn_1_1step_CC_maskV_-1.0=0.80105066, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52001053, val_rnn_1_1step_R2_maskV_-1.0=0.40203866, val_rnn_1_1step_CC_maskV_-1.0=0.69473851, learning_rate=0.001\n", + "Epoch 229/377 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33757818, rnn_1_1step_R2_maskV_-1.0=0.65045834, rnn_1_1step_CC_maskV_-1.0=0.81304014, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50260943, val_rnn_1_1step_R2_maskV_-1.0=0.42209306, val_rnn_1_1step_CC_maskV_-1.0=0.70938963, learning_rate=0.001\n", + "Epoch 267/377 - loss=rnn_1_1step_loss=0.32607004, rnn_1_1step_R2_maskV_-1.0=0.66224402, rnn_1_1step_CC_maskV_-1.0=0.81985205, rnn_1_1step_MSE_maskV_-1.0=0.32607001, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49651814, val_rnn_1_1step_R2_maskV_-1.0=0.42901355, val_rnn_1_1step_CC_maskV_-1.0=0.71628857, learning_rate=0.001\n", + "Epoch 305/377 - loss=rnn_1_1step_loss=0.31914696, rnn_1_1step_R2_maskV_-1.0=0.66943443, rnn_1_1step_CC_maskV_-1.0=0.82411641, rnn_1_1step_MSE_maskV_-1.0=0.31914693, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49264362, val_rnn_1_1step_R2_maskV_-1.0=0.43362561, val_rnn_1_1step_CC_maskV_-1.0=0.71882945, learning_rate=0.001\n", + "Epoch 343/377 - loss=rnn_1_1step_loss=0.31372717, rnn_1_1step_R2_maskV_-1.0=0.6751467, rnn_1_1step_CC_maskV_-1.0=0.82756257, rnn_1_1step_MSE_maskV_-1.0=0.31372714, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48933554, val_rnn_1_1step_R2_maskV_-1.0=0.43750441, val_rnn_1_1step_CC_maskV_-1.0=0.72047949, learning_rate=0.001\n", + "Epoch 377/377 - loss=rnn_1_1step_loss=0.30934963, rnn_1_1step_R2_maskV_-1.0=0.67971009, rnn_1_1step_CC_maskV_-1.0=0.83002764, rnn_1_1step_MSE_maskV_-1.0=0.3093496, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48971376, val_rnn_1_1step_R2_maskV_-1.0=0.43699506, val_rnn_1_1step_CC_maskV_-1.0=0.72255248, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:38:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 36.03s\n", + "\u001b[32m2025-05-30 14:38:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.48776197)\n", + "\u001b[32m2025-05-30 14:38:45\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.277, R2_maskV_-1.0=0.723, CC_maskV_-1.0=0.85\n", + "\u001b[32m2025-05-30 14:38:46\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.465, R2_maskV_-1.0=0.478, CC_maskV_-1.0=0.741\n", + "\u001b[32m2025-05-30 14:38:46\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 14:38:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:39:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 133 (stopped at 148 epochs).\n", + "\u001b[32m2025-05-30 14:39:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/149 - loss=16.266308, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.016305435, MSE_maskV_-1.0=16.226515, val_loss=3.380744, val_CC_maskV_-1.0=0.035288982, val_MSE_maskV_-1.0=3.353513, learning_rate=0.001\n", + "Epoch 16/149 - loss=0.85750395, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38210779, MSE_maskV_-1.0=0.85823441, val_loss=0.85868627, val_CC_maskV_-1.0=0.39056644, val_MSE_maskV_-1.0=0.85573804, learning_rate=0.001\n", + "Epoch 31/149 - loss=0.78485024, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46279722, MSE_maskV_-1.0=0.78508109, val_loss=0.79257649, val_CC_maskV_-1.0=0.4601244, val_MSE_maskV_-1.0=0.79078782, learning_rate=0.001\n", + "Epoch 46/149 - loss=0.75362545, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49576762, MSE_maskV_-1.0=0.75354058, val_loss=0.76473838, val_CC_maskV_-1.0=0.48782918, val_MSE_maskV_-1.0=0.76350719, learning_rate=0.001\n", + "Epoch 61/149 - loss=0.73843569, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51042432, MSE_maskV_-1.0=0.73780239, val_loss=0.74806762, val_CC_maskV_-1.0=0.50374055, val_MSE_maskV_-1.0=0.74674666, learning_rate=0.001\n", + "Epoch 76/149 - loss=0.72953683, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51849347, MSE_maskV_-1.0=0.7293058, val_loss=0.73879528, val_CC_maskV_-1.0=0.5120244, val_MSE_maskV_-1.0=0.73766536, learning_rate=0.001\n", + "Epoch 91/149 - loss=0.72521245, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52311158, MSE_maskV_-1.0=0.72549665, val_loss=0.73703223, val_CC_maskV_-1.0=0.5141148, val_MSE_maskV_-1.0=0.7355845, learning_rate=0.001\n", + "Epoch 106/149 - loss=0.72162896, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52568436, MSE_maskV_-1.0=0.72092587, val_loss=0.73273456, val_CC_maskV_-1.0=0.51702756, val_MSE_maskV_-1.0=0.73154998, learning_rate=0.001\n", + "Epoch 121/149 - loss=0.71956497, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5281775, MSE_maskV_-1.0=0.71941799, val_loss=0.72827166, val_CC_maskV_-1.0=0.5228762, val_MSE_maskV_-1.0=0.72714257, learning_rate=0.001\n", + "Epoch 136/149 - loss=0.7175231, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52997923, MSE_maskV_-1.0=0.71775323, val_loss=0.72679543, val_CC_maskV_-1.0=0.52290887, val_MSE_maskV_-1.0=0.72535753, learning_rate=0.001\n", + "Epoch 149/149 - loss=0.71618003, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53127187, MSE_maskV_-1.0=0.71673769, val_loss=0.72393233, val_CC_maskV_-1.0=0.52542371, val_MSE_maskV_-1.0=0.72290099, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:39:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 36.01s\n", + "\u001b[32m2025-05-30 14:39:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:39:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 133 (stopped at 148 epochs).\n", + "\u001b[32m2025-05-30 14:39:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/149 - loss=10.747819, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.017638091, MSE_maskV_-1.0=10.724023, val_loss=2.9742165, val_CC_maskV_-1.0=0.057942756, val_MSE_maskV_-1.0=2.9465265, learning_rate=0.001\n", + "Epoch 16/149 - loss=0.86239755, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37671286, MSE_maskV_-1.0=0.86291897, val_loss=0.86095774, val_CC_maskV_-1.0=0.38809559, val_MSE_maskV_-1.0=0.8587364, learning_rate=0.001\n", + "Epoch 31/149 - loss=0.7891565, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45827138, MSE_maskV_-1.0=0.78938699, val_loss=0.79681885, val_CC_maskV_-1.0=0.45677796, val_MSE_maskV_-1.0=0.79524338, learning_rate=0.001\n", + "Epoch 46/149 - loss=0.75845999, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49076995, MSE_maskV_-1.0=0.75838089, val_loss=0.76933891, val_CC_maskV_-1.0=0.48407277, val_MSE_maskV_-1.0=0.76817763, learning_rate=0.001\n", + "Epoch 61/149 - loss=0.7427116, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50626236, MSE_maskV_-1.0=0.7420482, val_loss=0.75292552, val_CC_maskV_-1.0=0.49968576, val_MSE_maskV_-1.0=0.75165051, learning_rate=0.001\n", + "Epoch 76/149 - loss=0.73320979, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51493883, MSE_maskV_-1.0=0.7329886, val_loss=0.74297786, val_CC_maskV_-1.0=0.50851673, val_MSE_maskV_-1.0=0.74189413, learning_rate=0.001\n", + "Epoch 91/149 - loss=0.7282418, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52031451, MSE_maskV_-1.0=0.72851121, val_loss=0.74045658, val_CC_maskV_-1.0=0.51131839, val_MSE_maskV_-1.0=0.73903424, learning_rate=0.001\n", + "Epoch 106/149 - loss=0.72406435, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52339828, MSE_maskV_-1.0=0.72335947, val_loss=0.73596662, val_CC_maskV_-1.0=0.51440185, val_MSE_maskV_-1.0=0.73477077, learning_rate=0.001\n", + "Epoch 121/149 - loss=0.72160929, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5263049, MSE_maskV_-1.0=0.72144574, val_loss=0.73097795, val_CC_maskV_-1.0=0.52068859, val_MSE_maskV_-1.0=0.72980994, learning_rate=0.001\n", + "Epoch 136/149 - loss=0.71925497, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52836466, MSE_maskV_-1.0=0.71948946, val_loss=0.7289663, val_CC_maskV_-1.0=0.52118707, val_MSE_maskV_-1.0=0.72748655, learning_rate=0.001\n", + "Epoch 149/149 - loss=0.71764475, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52993149, MSE_maskV_-1.0=0.71821034, val_loss=0.72576207, val_CC_maskV_-1.0=0.52400881, val_MSE_maskV_-1.0=0.72467887, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:39:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 35.76s\n", + "\u001b[32m2025-05-30 14:39:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.7226246)\n", + "\u001b[32m2025-05-30 14:39:57\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 726us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:39:58\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.718, R2_maskV_-1.0=0.283, CC_maskV_-1.0=0.531\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 711us/step\n", + "51/51 [==============================] - 0s 768us/step\n", + "84/84 [==============================] - 0s 731us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:39:58\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_Cz1HL64U_ErSV16\" (4/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_Cz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 14:39:58\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_Cy1HL64U_ErSV16\" (5/16)\n", + "\u001b[32m2025-05-30 14:39:58\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_Cy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 14:39:58\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 14:39:58\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 14:39:59\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 14:39:59\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 14:39:59\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 14:39:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:42:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 1462 (stopped at 1477 epochs).\n", + "\u001b[32m2025-05-30 14:42:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/1478 - loss=rnn_1step_loss=1.0015243, rnn_1step_R2_maskV_-1.0=-0.024423111, rnn_1step_CC_maskV_-1.0=-0.035900377, rnn_1step_MSE_maskV_-1.0=1.0015244, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.9629209, val_rnn_1step_R2_maskV_-1.0=-0.085210308, val_rnn_1step_CC_maskV_-1.0=0.10113239, learning_rate=0.001\n", + "Epoch 149/1478 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42890039, rnn_1step_R2_maskV_-1.0=0.55779541, rnn_1step_CC_maskV_-1.0=0.75390399, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53726888, val_rnn_1step_R2_maskV_-1.0=0.38412529, val_rnn_1step_CC_maskV_-1.0=0.68071359, learning_rate=0.001\n", + "Epoch 297/1478 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41713342, rnn_1step_R2_maskV_-1.0=0.56949937, rnn_1step_CC_maskV_-1.0=0.76175249, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53430563, val_rnn_1step_R2_maskV_-1.0=0.38768044, val_rnn_1step_CC_maskV_-1.0=0.68461996, learning_rate=0.001\n", + "Epoch 445/1478 - loss=rnn_1step_loss=0.41137886, rnn_1step_R2_maskV_-1.0=0.5750643, rnn_1step_CC_maskV_-1.0=0.76560652, rnn_1step_MSE_maskV_-1.0=0.41137883, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5316034, val_rnn_1step_R2_maskV_-1.0=0.39085072, val_rnn_1step_CC_maskV_-1.0=0.68691319, learning_rate=0.001\n", + "Epoch 593/1478 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40924481, rnn_1step_R2_maskV_-1.0=0.5771662, rnn_1step_CC_maskV_-1.0=0.76702499, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53069997, val_rnn_1step_R2_maskV_-1.0=0.39186627, val_rnn_1step_CC_maskV_-1.0=0.68755525, learning_rate=0.001\n", + "Epoch 741/1478 - loss=rnn_1step_loss=0.4079667, rnn_1step_R2_maskV_-1.0=0.57848549, rnn_1step_CC_maskV_-1.0=0.76786011, rnn_1step_MSE_maskV_-1.0=0.40796673, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52964753, val_rnn_1step_R2_maskV_-1.0=0.39302152, val_rnn_1step_CC_maskV_-1.0=0.68831122, learning_rate=0.001\n", + "Epoch 889/1478 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40668988, rnn_1step_R2_maskV_-1.0=0.57983673, rnn_1step_CC_maskV_-1.0=0.76869273, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5280633, val_rnn_1step_R2_maskV_-1.0=0.39475781, val_rnn_1step_CC_maskV_-1.0=0.68951601, learning_rate=0.001\n", + "Epoch 1037/1478 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40544522, rnn_1step_R2_maskV_-1.0=0.58118165, rnn_1step_CC_maskV_-1.0=0.76950908, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52601451, val_rnn_1step_R2_maskV_-1.0=0.39700359, val_rnn_1step_CC_maskV_-1.0=0.69109625, learning_rate=0.001\n", + "Epoch 1185/1478 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40451202, rnn_1step_R2_maskV_-1.0=0.58220673, rnn_1step_CC_maskV_-1.0=0.77012813, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52415097, val_rnn_1step_R2_maskV_-1.0=0.39908433, val_rnn_1step_CC_maskV_-1.0=0.6925146, learning_rate=0.001\n", + "Epoch 1333/1478 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40399519, rnn_1step_R2_maskV_-1.0=0.58279037, rnn_1step_CC_maskV_-1.0=0.77047992, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52309352, val_rnn_1step_R2_maskV_-1.0=0.40032855, val_rnn_1step_CC_maskV_-1.0=0.69330812, learning_rate=0.001\n", + "Epoch 1478/1478 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40383062, rnn_1step_R2_maskV_-1.0=0.5829916, rnn_1step_CC_maskV_-1.0=0.77060401, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52284306, val_rnn_1step_R2_maskV_-1.0=0.40068391, val_rnn_1step_CC_maskV_-1.0=0.6935041, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:42:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 123.06s\n", + "\u001b[32m2025-05-30 14:42:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:45:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/2500 - loss=rnn_1_1step_loss=0.99610204, rnn_1_1step_R2_maskV_-1.0=-0.018929366, rnn_1_1step_CC_maskV_-1.0=0.093735889, rnn_1_1step_MSE_maskV_-1.0=0.99610198, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.95866793, val_rnn_1_1step_R2_maskV_-1.0=-0.080692157, val_rnn_1_1step_CC_maskV_-1.0=0.20007679, learning_rate=0.001\n", + "Epoch 251/2500 - loss=rnn_1_1step_loss=0.41773233, rnn_1_1step_R2_maskV_-1.0=0.56890488, rnn_1_1step_CC_maskV_-1.0=0.76130873, rnn_1_1step_MSE_maskV_-1.0=0.4177323, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53544766, val_rnn_1_1step_R2_maskV_-1.0=0.38642985, val_rnn_1_1step_CC_maskV_-1.0=0.68442899, learning_rate=0.001\n", + "Epoch 501/2500 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40913272, rnn_1_1step_R2_maskV_-1.0=0.57740027, rnn_1_1step_CC_maskV_-1.0=0.76709545, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52781683, val_rnn_1_1step_R2_maskV_-1.0=0.39524415, val_rnn_1_1step_CC_maskV_-1.0=0.68963104, learning_rate=0.001\n", + "Epoch 751/2500 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40696773, rnn_1_1step_R2_maskV_-1.0=0.57961065, rnn_1_1step_CC_maskV_-1.0=0.76851761, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52640206, val_rnn_1_1step_R2_maskV_-1.0=0.39680105, val_rnn_1_1step_CC_maskV_-1.0=0.69085824, learning_rate=0.001\n", + "Epoch 1001/2500 - loss=rnn_1_1step_loss=0.40579665, rnn_1_1step_R2_maskV_-1.0=0.58088976, rnn_1_1step_CC_maskV_-1.0=0.76926219, rnn_1_1step_MSE_maskV_-1.0=0.40579668, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52554494, val_rnn_1_1step_R2_maskV_-1.0=0.39765432, val_rnn_1_1step_CC_maskV_-1.0=0.69179851, learning_rate=0.001\n", + "Epoch 1251/2500 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40526959, rnn_1_1step_R2_maskV_-1.0=0.58151597, rnn_1_1step_CC_maskV_-1.0=0.76959151, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5245809, val_rnn_1_1step_R2_maskV_-1.0=0.39866334, val_rnn_1_1step_CC_maskV_-1.0=0.69269156, learning_rate=0.001\n", + "Epoch 1501/2500 - loss=rnn_1_1step_loss=0.40517864, rnn_1_1step_R2_maskV_-1.0=0.58167934, rnn_1_1step_CC_maskV_-1.0=0.76963478, rnn_1_1step_MSE_maskV_-1.0=0.40517858, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52372378, val_rnn_1_1step_R2_maskV_-1.0=0.39959759, val_rnn_1_1step_CC_maskV_-1.0=0.69331366, learning_rate=0.001\n", + "Epoch 1751/2500 - loss=rnn_1_1step_loss=0.40498447, rnn_1_1step_R2_maskV_-1.0=0.58192205, rnn_1_1step_CC_maskV_-1.0=0.76976615, rnn_1_1step_MSE_maskV_-1.0=0.4049845, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52287924, val_rnn_1_1step_R2_maskV_-1.0=0.40056431, val_rnn_1_1step_CC_maskV_-1.0=0.69379723, learning_rate=0.001\n", + "Epoch 2001/2500 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40492687, rnn_1_1step_R2_maskV_-1.0=0.58201063, rnn_1_1step_CC_maskV_-1.0=0.76981217, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52226347, val_rnn_1_1step_R2_maskV_-1.0=0.40130079, val_rnn_1_1step_CC_maskV_-1.0=0.6941337, learning_rate=0.001\n", + "Epoch 2251/2500 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40502596, rnn_1_1step_R2_maskV_-1.0=0.58192527, rnn_1_1step_CC_maskV_-1.0=0.76975393, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5217402, val_rnn_1_1step_R2_maskV_-1.0=0.40196654, val_rnn_1_1step_CC_maskV_-1.0=0.69441175, learning_rate=0.001\n", + "Epoch 2500/2500 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40507904, rnn_1_1step_R2_maskV_-1.0=0.58186311, rnn_1_1step_CC_maskV_-1.0=0.76972735, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52120858, val_rnn_1_1step_R2_maskV_-1.0=0.40266708, val_rnn_1_1step_CC_maskV_-1.0=0.69469881, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:45:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 207.58s\n", + "\u001b[32m2025-05-30 14:45:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.52120858)\n", + "\u001b[32m2025-05-30 14:45:30\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.363, R2_maskV_-1.0=0.637, CC_maskV_-1.0=0.798\n", + "\u001b[32m2025-05-30 14:45:31\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.501, R2_maskV_-1.0=0.439, CC_maskV_-1.0=0.714\n", + "\u001b[32m2025-05-30 14:45:31\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 14:45:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:46:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 117 (stopped at 132 epochs).\n", + "\u001b[32m2025-05-30 14:46:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/133 - loss=45.984928, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0040050922, MSE_maskV_-1.0=45.86422, val_loss=5.6206465, val_CC_maskV_-1.0=0.0049023489, val_MSE_maskV_-1.0=5.5876532, learning_rate=0.001\n", + "Epoch 15/133 - loss=1.0242879, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.235985, MSE_maskV_-1.0=1.0242635, val_loss=1.0383561, val_CC_maskV_-1.0=0.23273732, val_MSE_maskV_-1.0=1.0352405, learning_rate=0.001\n", + "Epoch 29/133 - loss=0.89971602, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3482058, MSE_maskV_-1.0=0.89885902, val_loss=0.90760046, val_CC_maskV_-1.0=0.34424302, val_MSE_maskV_-1.0=0.90508366, learning_rate=0.001\n", + "Epoch 43/133 - loss=0.82588923, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42345065, MSE_maskV_-1.0=0.82611609, val_loss=0.85773218, val_CC_maskV_-1.0=0.39987877, val_MSE_maskV_-1.0=0.85682392, learning_rate=0.001\n", + "Epoch 57/133 - loss=0.77584499, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47288984, MSE_maskV_-1.0=0.77613139, val_loss=0.80007863, val_CC_maskV_-1.0=0.45352069, val_MSE_maskV_-1.0=0.79908836, learning_rate=0.001\n", + "Epoch 71/133 - loss=0.75025576, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49816439, MSE_maskV_-1.0=0.75108361, val_loss=0.7851755, val_CC_maskV_-1.0=0.46726355, val_MSE_maskV_-1.0=0.7851671, learning_rate=0.001\n", + "Epoch 85/133 - loss=0.73593861, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51190788, MSE_maskV_-1.0=0.73607612, val_loss=0.76416212, val_CC_maskV_-1.0=0.48822075, val_MSE_maskV_-1.0=0.76407951, learning_rate=0.001\n", + "Epoch 99/133 - loss=0.73228323, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51523656, MSE_maskV_-1.0=0.73212105, val_loss=0.7714569, val_CC_maskV_-1.0=0.48492032, val_MSE_maskV_-1.0=0.77082384, learning_rate=0.001\n", + "Epoch 113/133 - loss=0.72782916, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51986557, MSE_maskV_-1.0=0.73023212, val_loss=0.77033609, val_CC_maskV_-1.0=0.48623851, val_MSE_maskV_-1.0=0.76960844, learning_rate=0.001\n", + "Epoch 127/133 - loss=0.72315001, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52420294, MSE_maskV_-1.0=0.72466493, val_loss=0.76009089, val_CC_maskV_-1.0=0.49340156, val_MSE_maskV_-1.0=0.75898558, learning_rate=0.001\n", + "Epoch 133/133 - loss=0.72104192, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52682418, MSE_maskV_-1.0=0.72032994, val_loss=0.7717225, val_CC_maskV_-1.0=0.48579791, val_MSE_maskV_-1.0=0.77067471, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:46:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 34.28s\n", + "\u001b[32m2025-05-30 14:46:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:46:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 122 (stopped at 137 epochs).\n", + "\u001b[32m2025-05-30 14:46:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/138 - loss=63.901043, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0012826365, MSE_maskV_-1.0=63.725651, val_loss=6.6622233, val_CC_maskV_-1.0=0.0040634647, val_MSE_maskV_-1.0=6.6162558, learning_rate=0.001\n", + "Epoch 15/138 - loss=1.057072, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.21150546, MSE_maskV_-1.0=1.0572723, val_loss=1.0663593, val_CC_maskV_-1.0=0.20629004, val_MSE_maskV_-1.0=1.0657502, learning_rate=0.001\n", + "Epoch 29/138 - loss=0.94043821, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.30980289, MSE_maskV_-1.0=0.93952364, val_loss=0.9496485, val_CC_maskV_-1.0=0.30203962, val_MSE_maskV_-1.0=0.94813895, learning_rate=0.001\n", + "Epoch 43/138 - loss=0.854801, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39365438, MSE_maskV_-1.0=0.85511774, val_loss=0.87532127, val_CC_maskV_-1.0=0.37904796, val_MSE_maskV_-1.0=0.8744995, learning_rate=0.001\n", + "Epoch 57/138 - loss=0.80358034, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44558233, MSE_maskV_-1.0=0.80379701, val_loss=0.83538908, val_CC_maskV_-1.0=0.41712764, val_MSE_maskV_-1.0=0.8351019, learning_rate=0.001\n", + "Epoch 71/138 - loss=0.76805276, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48038197, MSE_maskV_-1.0=0.76892847, val_loss=0.81225336, val_CC_maskV_-1.0=0.44116199, val_MSE_maskV_-1.0=0.81113499, learning_rate=0.001\n", + "Epoch 85/138 - loss=0.7425335, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50537872, MSE_maskV_-1.0=0.74282801, val_loss=0.77029395, val_CC_maskV_-1.0=0.48155698, val_MSE_maskV_-1.0=0.77076769, learning_rate=0.001\n", + "Epoch 99/138 - loss=0.73801172, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50952739, MSE_maskV_-1.0=0.73781407, val_loss=0.77129102, val_CC_maskV_-1.0=0.48178193, val_MSE_maskV_-1.0=0.77152896, learning_rate=0.001\n", + "Epoch 113/138 - loss=0.73009223, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51799047, MSE_maskV_-1.0=0.73239768, val_loss=0.77172625, val_CC_maskV_-1.0=0.48382872, val_MSE_maskV_-1.0=0.7718097, learning_rate=0.001\n", + "Epoch 127/138 - loss=0.72616106, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52132148, MSE_maskV_-1.0=0.72754937, val_loss=0.75918919, val_CC_maskV_-1.0=0.49255416, val_MSE_maskV_-1.0=0.75820398, learning_rate=0.001\n", + "Epoch 138/138 - loss=0.72409528, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52385849, MSE_maskV_-1.0=0.72410142, val_loss=0.76382005, val_CC_maskV_-1.0=0.48897919, val_MSE_maskV_-1.0=0.76280427, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:46:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 35.35s\n", + "\u001b[32m2025-05-30 14:46:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.75009131)\n", + "\u001b[32m2025-05-30 14:46:40\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 743us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:46:41\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.713, R2_maskV_-1.0=0.288, CC_maskV_-1.0=0.536\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 744us/step\n", + "51/51 [==============================] - 0s 793us/step\n", + "84/84 [==============================] - 0s 768us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:46:41\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_Cy1HL64U_ErSV16\" (5/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_Cy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 14:46:41\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_uAK1HL64U_ErSV16\" (6/16)\n", + "\u001b[32m2025-05-30 14:46:41\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAK1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 14:46:41\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 14:46:41\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 14:46:42\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 14:46:42\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 14:46:42\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 14:46:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:46:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 89 (stopped at 104 epochs).\n", + "\u001b[32m2025-05-30 14:46:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.99899942, rnn_1step_R2_maskV_-1.0=-0.021893665, rnn_1step_CC_maskV_-1.0=0.070017986, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96443206, val_rnn_1step_R2_maskV_-1.0=-0.087099969, val_rnn_1step_CC_maskV_-1.0=0.28403565, learning_rate=0.001\n", + "Epoch 12/105 - loss=rnn_1step_loss=0.81571573, rnn_1step_R2_maskV_-1.0=0.16298346, rnn_1step_CC_maskV_-1.0=0.43939108, rnn_1step_MSE_maskV_-1.0=0.81571567, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.80411625, val_rnn_1step_R2_maskV_-1.0=0.084824488, val_rnn_1step_CC_maskV_-1.0=0.40630794, learning_rate=0.001\n", + "Epoch 23/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.56037998, rnn_1step_R2_maskV_-1.0=0.41749814, rnn_1step_CC_maskV_-1.0=0.6642518, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6296702, val_rnn_1step_R2_maskV_-1.0=0.27913773, val_rnn_1step_CC_maskV_-1.0=0.59536797, learning_rate=0.001\n", + "Epoch 34/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.45211902, rnn_1step_R2_maskV_-1.0=0.52932382, rnn_1step_CC_maskV_-1.0=0.74020034, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57985455, val_rnn_1step_R2_maskV_-1.0=0.33714283, val_rnn_1step_CC_maskV_-1.0=0.63825887, learning_rate=0.001\n", + "Epoch 45/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37806287, rnn_1step_R2_maskV_-1.0=0.60689324, rnn_1step_CC_maskV_-1.0=0.78895462, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56191093, val_rnn_1step_R2_maskV_-1.0=0.35733962, val_rnn_1step_CC_maskV_-1.0=0.6584664, learning_rate=0.001\n", + "Epoch 56/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32477453, rnn_1step_R2_maskV_-1.0=0.66195649, rnn_1step_CC_maskV_-1.0=0.8209424, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55964184, val_rnn_1step_R2_maskV_-1.0=0.35988396, val_rnn_1step_CC_maskV_-1.0=0.66543996, learning_rate=0.001\n", + "Epoch 67/105 - loss=rnn_1step_loss=0.28464952, rnn_1step_R2_maskV_-1.0=0.70405334, rnn_1step_CC_maskV_-1.0=0.84498203, rnn_1step_MSE_maskV_-1.0=0.28464949, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54789668, val_rnn_1step_R2_maskV_-1.0=0.37357026, val_rnn_1step_CC_maskV_-1.0=0.67601705, learning_rate=0.001\n", + "Epoch 78/105 - loss=rnn_1step_loss=0.2636354, rnn_1step_R2_maskV_-1.0=0.72643209, rnn_1step_CC_maskV_-1.0=0.85712647, rnn_1step_MSE_maskV_-1.0=0.26363543, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54179364, val_rnn_1step_R2_maskV_-1.0=0.37931246, val_rnn_1step_CC_maskV_-1.0=0.68212521, learning_rate=0.001\n", + "Epoch 89/105 - loss=rnn_1step_loss=0.24702351, rnn_1step_R2_maskV_-1.0=0.74426997, rnn_1step_CC_maskV_-1.0=0.86711484, rnn_1step_MSE_maskV_-1.0=0.24702348, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51889968, val_rnn_1step_R2_maskV_-1.0=0.40808049, val_rnn_1step_CC_maskV_-1.0=0.69409317, learning_rate=0.001\n", + "Epoch 100/105 - loss=rnn_1step_loss=0.23538037, rnn_1step_R2_maskV_-1.0=0.75635117, rnn_1step_CC_maskV_-1.0=0.87338746, rnn_1step_MSE_maskV_-1.0=0.23538038, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52654952, val_rnn_1step_R2_maskV_-1.0=0.39888531, val_rnn_1step_CC_maskV_-1.0=0.69203216, learning_rate=0.001\n", + "Epoch 105/105 - loss=rnn_1step_loss=0.23175292, rnn_1step_R2_maskV_-1.0=0.76037633, rnn_1step_CC_maskV_-1.0=0.87583798, rnn_1step_MSE_maskV_-1.0=0.2317529, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54414326, val_rnn_1step_R2_maskV_-1.0=0.37861425, val_rnn_1step_CC_maskV_-1.0=0.68166983, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:46:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.65s\n", + "\u001b[32m2025-05-30 14:46:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:47:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 54 (stopped at 69 epochs).\n", + "\u001b[32m2025-05-30 14:47:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/70 - loss=rnn_1_1step_loss=0.99891281, rnn_1_1step_R2_maskV_-1.0=-0.021801177, rnn_1_1step_CC_maskV_-1.0=0.081306055, rnn_1_1step_MSE_maskV_-1.0=0.99891287, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96328878, val_rnn_1_1step_R2_maskV_-1.0=-0.085758388, val_rnn_1_1step_CC_maskV_-1.0=0.25274381, learning_rate=0.001\n", + "Epoch 8/70 - loss=rnn_1_1step_loss=0.93684751, rnn_1_1step_R2_maskV_-1.0=0.042010859, rnn_1_1step_CC_maskV_-1.0=0.3942045, rnn_1_1step_MSE_maskV_-1.0=0.93684745, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.89523572, val_rnn_1_1step_R2_maskV_-1.0=-0.012762502, val_rnn_1_1step_CC_maskV_-1.0=0.37401849, learning_rate=0.001\n", + "Epoch 15/70 - loss=rnn_1_1step_loss=0.7254495, rnn_1_1step_R2_maskV_-1.0=0.25457901, rnn_1_1step_CC_maskV_-1.0=0.52814925, rnn_1_1step_MSE_maskV_-1.0=0.72544938, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.70908219, val_rnn_1_1step_R2_maskV_-1.0=0.19181791, val_rnn_1_1step_CC_maskV_-1.0=0.5148471, learning_rate=0.001\n", + "Epoch 22/70 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.59417814, rnn_1_1step_R2_maskV_-1.0=0.38473213, rnn_1_1step_CC_maskV_-1.0=0.63508862, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64882278, val_rnn_1_1step_R2_maskV_-1.0=0.25876552, val_rnn_1_1step_CC_maskV_-1.0=0.5777573, learning_rate=0.001\n", + "Epoch 29/70 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.51353496, rnn_1_1step_R2_maskV_-1.0=0.46780944, rnn_1_1step_CC_maskV_-1.0=0.69602466, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6011557, val_rnn_1_1step_R2_maskV_-1.0=0.31239945, val_rnn_1_1step_CC_maskV_-1.0=0.61811507, learning_rate=0.001\n", + "Epoch 36/70 - loss=rnn_1_1step_loss=0.43883052, rnn_1_1step_R2_maskV_-1.0=0.54549122, rnn_1_1step_CC_maskV_-1.0=0.74781942, rnn_1_1step_MSE_maskV_-1.0=0.43883055, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55850178, val_rnn_1_1step_R2_maskV_-1.0=0.36139065, val_rnn_1_1step_CC_maskV_-1.0=0.6522392, learning_rate=0.001\n", + "Epoch 43/70 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39123479, rnn_1_1step_R2_maskV_-1.0=0.59454954, rnn_1_1step_CC_maskV_-1.0=0.77880746, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53127831, val_rnn_1_1step_R2_maskV_-1.0=0.39083594, val_rnn_1_1step_CC_maskV_-1.0=0.67454219, learning_rate=0.001\n", + "Epoch 50/70 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36401811, rnn_1_1step_R2_maskV_-1.0=0.62256801, rnn_1_1step_CC_maskV_-1.0=0.79587859, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53482819, val_rnn_1_1step_R2_maskV_-1.0=0.38554257, val_rnn_1_1step_CC_maskV_-1.0=0.67683393, learning_rate=0.001\n", + "Epoch 57/70 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.3453562, rnn_1_1step_R2_maskV_-1.0=0.64185405, rnn_1_1step_CC_maskV_-1.0=0.80800831, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53450018, val_rnn_1_1step_R2_maskV_-1.0=0.38575363, val_rnn_1_1step_CC_maskV_-1.0=0.67844635, learning_rate=0.001\n", + "Epoch 64/70 - loss=rnn_1_1step_loss=0.32632583, rnn_1_1step_R2_maskV_-1.0=0.66166377, rnn_1_1step_CC_maskV_-1.0=0.81976962, rnn_1_1step_MSE_maskV_-1.0=0.32632586, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53411216, val_rnn_1_1step_R2_maskV_-1.0=0.3871119, val_rnn_1_1step_CC_maskV_-1.0=0.67831028, learning_rate=0.001\n", + "Epoch 70/70 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30584121, rnn_1_1step_R2_maskV_-1.0=0.6832118, rnn_1_1step_CC_maskV_-1.0=0.83194602, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55367213, val_rnn_1_1step_R2_maskV_-1.0=0.36430943, val_rnn_1_1step_CC_maskV_-1.0=0.67183179, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:47:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 9.28s\n", + "\u001b[32m2025-05-30 14:47:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.51889968)\n", + "\u001b[32m2025-05-30 14:47:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.23, R2_maskV_-1.0=0.77, CC_maskV_-1.0=0.877\n", + "\u001b[32m2025-05-30 14:47:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.486, R2_maskV_-1.0=0.46, CC_maskV_-1.0=0.721\n", + "\u001b[32m2025-05-30 14:47:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 14:47:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:48:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 314 (stopped at 329 epochs).\n", + "\u001b[32m2025-05-30 14:48:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/330 - loss=1.3478811, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.059286408, MSE_maskV_-1.0=1.3488085, val_loss=1.0180092, val_CC_maskV_-1.0=0.12644283, val_MSE_maskV_-1.0=1.0156077, learning_rate=0.001\n", + "Epoch 34/330 - loss=0.8993178, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.32440618, MSE_maskV_-1.0=0.90129107, val_loss=0.90800691, val_CC_maskV_-1.0=0.32673416, val_MSE_maskV_-1.0=0.90527248, learning_rate=0.001\n", + "Epoch 67/330 - loss=0.8756209, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36110231, MSE_maskV_-1.0=0.87507159, val_loss=0.88536906, val_CC_maskV_-1.0=0.3601127, val_MSE_maskV_-1.0=0.88272041, learning_rate=0.001\n", + "Epoch 100/330 - loss=0.86234528, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37711582, MSE_maskV_-1.0=0.86162078, val_loss=0.87240082, val_CC_maskV_-1.0=0.37522593, val_MSE_maskV_-1.0=0.86983705, learning_rate=0.001\n", + "Epoch 133/330 - loss=0.85412985, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38648608, MSE_maskV_-1.0=0.85334003, val_loss=0.86469185, val_CC_maskV_-1.0=0.38387257, val_MSE_maskV_-1.0=0.8620593, learning_rate=0.001\n", + "Epoch 166/330 - loss=0.84837872, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39276701, MSE_maskV_-1.0=0.84911245, val_loss=0.85901135, val_CC_maskV_-1.0=0.39014107, val_MSE_maskV_-1.0=0.85620993, learning_rate=0.001\n", + "Epoch 199/330 - loss=0.84454507, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39757922, MSE_maskV_-1.0=0.84462041, val_loss=0.8559261, val_CC_maskV_-1.0=0.39263916, val_MSE_maskV_-1.0=0.85309869, learning_rate=0.001\n", + "Epoch 232/330 - loss=0.8413735, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40028203, MSE_maskV_-1.0=0.84083664, val_loss=0.85226375, val_CC_maskV_-1.0=0.39609596, val_MSE_maskV_-1.0=0.84945828, learning_rate=0.001\n", + "Epoch 265/330 - loss=0.83909535, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40287694, MSE_maskV_-1.0=0.83953726, val_loss=0.85224468, val_CC_maskV_-1.0=0.39659056, val_MSE_maskV_-1.0=0.84940159, learning_rate=0.001\n", + "Epoch 298/330 - loss=0.83738607, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.404906, MSE_maskV_-1.0=0.83705634, val_loss=0.84762436, val_CC_maskV_-1.0=0.40020722, val_MSE_maskV_-1.0=0.845245, learning_rate=0.001\n", + "Epoch 330/330 - loss=0.83606178, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40650344, MSE_maskV_-1.0=0.83562642, val_loss=0.8485465, val_CC_maskV_-1.0=0.4001995, val_MSE_maskV_-1.0=0.84531486, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:48:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 76.06s\n", + "\u001b[32m2025-05-30 14:48:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:49:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 314 (stopped at 329 epochs).\n", + "\u001b[32m2025-05-30 14:49:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/330 - loss=1.3822443, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.059996258, MSE_maskV_-1.0=1.3833165, val_loss=1.0185571, val_CC_maskV_-1.0=0.12699799, val_MSE_maskV_-1.0=1.016687, learning_rate=0.001\n", + "Epoch 34/330 - loss=0.90205669, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.32008153, MSE_maskV_-1.0=0.90401119, val_loss=0.91180056, val_CC_maskV_-1.0=0.32038847, val_MSE_maskV_-1.0=0.90928012, learning_rate=0.001\n", + "Epoch 67/330 - loss=0.8775177, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35826731, MSE_maskV_-1.0=0.87697804, val_loss=0.88818187, val_CC_maskV_-1.0=0.35575077, val_MSE_maskV_-1.0=0.88577265, learning_rate=0.001\n", + "Epoch 100/330 - loss=0.8638429, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37502649, MSE_maskV_-1.0=0.86310875, val_loss=0.87452734, val_CC_maskV_-1.0=0.37228858, val_MSE_maskV_-1.0=0.87216169, learning_rate=0.001\n", + "Epoch 133/330 - loss=0.85529953, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38500667, MSE_maskV_-1.0=0.8545025, val_loss=0.86629343, val_CC_maskV_-1.0=0.38184798, val_MSE_maskV_-1.0=0.86384904, learning_rate=0.001\n", + "Epoch 166/330 - loss=0.8492918, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39164731, MSE_maskV_-1.0=0.85002851, val_loss=0.86030656, val_CC_maskV_-1.0=0.38860479, val_MSE_maskV_-1.0=0.85765886, learning_rate=0.001\n", + "Epoch 199/330 - loss=0.84524065, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39677384, MSE_maskV_-1.0=0.84532022, val_loss=0.85696316, val_CC_maskV_-1.0=0.39143953, val_MSE_maskV_-1.0=0.8542797, learning_rate=0.001\n", + "Epoch 232/330 - loss=0.84191614, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3997283, MSE_maskV_-1.0=0.8413738, val_loss=0.85309118, val_CC_maskV_-1.0=0.39517695, val_MSE_maskV_-1.0=0.85041547, learning_rate=0.001\n", + "Epoch 265/330 - loss=0.83951688, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40241075, MSE_maskV_-1.0=0.83995908, val_loss=0.85291278, val_CC_maskV_-1.0=0.39590132, val_MSE_maskV_-1.0=0.8501811, learning_rate=0.001\n", + "Epoch 298/330 - loss=0.83771515, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40457848, MSE_maskV_-1.0=0.83738047, val_loss=0.84815031, val_CC_maskV_-1.0=0.39963493, val_MSE_maskV_-1.0=0.84588164, learning_rate=0.001\n", + "Epoch 330/330 - loss=0.83631903, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40623194, MSE_maskV_-1.0=0.83588552, val_loss=0.84900624, val_CC_maskV_-1.0=0.3997314, val_MSE_maskV_-1.0=0.84586316, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:49:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 78.03s\n", + "\u001b[32m2025-05-30 14:49:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.84627157)\n", + "\u001b[32m2025-05-30 14:49:39\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 726us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:49:40\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.836, R2_maskV_-1.0=0.164, CC_maskV_-1.0=0.407\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 735us/step\n", + "51/51 [==============================] - 0s 745us/step\n", + "84/84 [==============================] - 0s 679us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:49:40\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_uAK1HL64U_ErSV16\" (6/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_uAK1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 14:49:40\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_ACz1HL64U_ErSV16\" (7/16)\n", + "\u001b[32m2025-05-30 14:49:40\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 14:49:40\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 14:49:40\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 14:49:41\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 14:49:41\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 14:49:41\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 14:49:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:49:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 144 (stopped at 159 epochs).\n", + "\u001b[32m2025-05-30 14:49:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/160 - loss=rnn_1step_loss=0.99938148, rnn_1step_R2_maskV_-1.0=-0.022286579, rnn_1step_CC_maskV_-1.0=0.019430524, rnn_1step_MSE_maskV_-1.0=0.99938142, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96399927, val_rnn_1step_R2_maskV_-1.0=-0.086555734, val_rnn_1step_CC_maskV_-1.0=0.23515102, learning_rate=0.001\n", + "Epoch 17/160 - loss=rnn_1step_loss=0.70371658, rnn_1step_R2_maskV_-1.0=0.27361703, rnn_1step_CC_maskV_-1.0=0.54582232, rnn_1step_MSE_maskV_-1.0=0.70371652, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.74436575, val_rnn_1step_R2_maskV_-1.0=0.15156496, val_rnn_1step_CC_maskV_-1.0=0.49312967, learning_rate=0.001\n", + "Epoch 33/160 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.54233909, rnn_1step_R2_maskV_-1.0=0.43817532, rnn_1step_CC_maskV_-1.0=0.67638826, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63959926, val_rnn_1step_R2_maskV_-1.0=0.27089587, val_rnn_1step_CC_maskV_-1.0=0.58778262, learning_rate=0.001\n", + "Epoch 49/160 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.49734187, rnn_1step_R2_maskV_-1.0=0.48500833, rnn_1step_CC_maskV_-1.0=0.70845127, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61583602, val_rnn_1step_R2_maskV_-1.0=0.29759139, val_rnn_1step_CC_maskV_-1.0=0.60832894, learning_rate=0.001\n", + "Epoch 65/160 - loss=rnn_1step_loss=0.47111833, rnn_1step_R2_maskV_-1.0=0.51193511, rnn_1step_CC_maskV_-1.0=0.72790021, rnn_1step_MSE_maskV_-1.0=0.47111836, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59655696, val_rnn_1step_R2_maskV_-1.0=0.31963432, val_rnn_1step_CC_maskV_-1.0=0.62068903, learning_rate=0.001\n", + "Epoch 81/160 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.44328356, rnn_1step_R2_maskV_-1.0=0.54044855, rnn_1step_CC_maskV_-1.0=0.74673766, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57868606, val_rnn_1step_R2_maskV_-1.0=0.3385694, val_rnn_1step_CC_maskV_-1.0=0.63438165, learning_rate=0.001\n", + "Epoch 97/160 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41398975, rnn_1step_R2_maskV_-1.0=0.57038653, rnn_1step_CC_maskV_-1.0=0.76714969, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55835527, val_rnn_1step_R2_maskV_-1.0=0.35923725, val_rnn_1step_CC_maskV_-1.0=0.65437865, learning_rate=0.001\n", + "Epoch 113/160 - loss=rnn_1step_loss=0.39746562, rnn_1step_R2_maskV_-1.0=0.58645874, rnn_1step_CC_maskV_-1.0=0.77677691, rnn_1step_MSE_maskV_-1.0=0.39746559, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51956677, val_rnn_1step_R2_maskV_-1.0=0.40373707, val_rnn_1step_CC_maskV_-1.0=0.68019539, learning_rate=0.001\n", + "Epoch 129/160 - loss=rnn_1step_loss=0.36984655, rnn_1step_R2_maskV_-1.0=0.61538953, rnn_1step_CC_maskV_-1.0=0.79457021, rnn_1step_MSE_maskV_-1.0=0.36984652, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5095976, val_rnn_1step_R2_maskV_-1.0=0.41497761, val_rnn_1step_CC_maskV_-1.0=0.68978512, learning_rate=0.001\n", + "Epoch 145/160 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37863436, rnn_1step_R2_maskV_-1.0=0.60708559, rnn_1step_CC_maskV_-1.0=0.78964901, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49519953, val_rnn_1step_R2_maskV_-1.0=0.43135503, val_rnn_1step_CC_maskV_-1.0=0.69680583, learning_rate=0.001\n", + "Epoch 160/160 - loss=rnn_1step_loss=0.35432336, rnn_1step_R2_maskV_-1.0=0.63163674, rnn_1step_CC_maskV_-1.0=0.80220795, rnn_1step_MSE_maskV_-1.0=0.35432333, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51592165, val_rnn_1step_R2_maskV_-1.0=0.40587333, val_rnn_1step_CC_maskV_-1.0=0.69386035, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:49:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 18.74s\n", + "\u001b[32m2025-05-30 14:50:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:50:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 147 (stopped at 162 epochs).\n", + "\u001b[32m2025-05-30 14:50:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/163 - loss=rnn_1_1step_loss=0.99937296, rnn_1_1step_R2_maskV_-1.0=-0.022319585, rnn_1_1step_CC_maskV_-1.0=0.025256641, rnn_1_1step_MSE_maskV_-1.0=0.99937302, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96580678, val_rnn_1_1step_R2_maskV_-1.0=-0.088675171, val_rnn_1_1step_CC_maskV_-1.0=0.085981011, learning_rate=0.001\n", + "Epoch 18/163 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.73633832, rnn_1_1step_R2_maskV_-1.0=0.24150087, rnn_1_1step_CC_maskV_-1.0=0.52327448, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.7397458, val_rnn_1_1step_R2_maskV_-1.0=0.15458654, val_rnn_1_1step_CC_maskV_-1.0=0.47738519, learning_rate=0.001\n", + "Epoch 35/163 - loss=rnn_1_1step_loss=0.56401652, rnn_1_1step_R2_maskV_-1.0=0.4162333, rnn_1_1step_CC_maskV_-1.0=0.65888798, rnn_1_1step_MSE_maskV_-1.0=0.56401658, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63901812, val_rnn_1_1step_R2_maskV_-1.0=0.27164349, val_rnn_1_1step_CC_maskV_-1.0=0.58424741, learning_rate=0.001\n", + "Epoch 52/163 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.48122227, rnn_1_1step_R2_maskV_-1.0=0.50262594, rnn_1_1step_CC_maskV_-1.0=0.7189281, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58520275, val_rnn_1_1step_R2_maskV_-1.0=0.33234799, val_rnn_1_1step_CC_maskV_-1.0=0.63414085, learning_rate=0.001\n", + "Epoch 69/163 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42761958, rnn_1_1step_R2_maskV_-1.0=0.55748302, rnn_1_1step_CC_maskV_-1.0=0.75548559, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54234004, val_rnn_1_1step_R2_maskV_-1.0=0.37909046, val_rnn_1_1step_CC_maskV_-1.0=0.66685522, learning_rate=0.001\n", + "Epoch 86/163 - loss=rnn_1_1step_loss=0.40188813, rnn_1_1step_R2_maskV_-1.0=0.58428216, rnn_1_1step_CC_maskV_-1.0=0.77175409, rnn_1_1step_MSE_maskV_-1.0=0.4018881, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52486044, val_rnn_1_1step_R2_maskV_-1.0=0.39891934, val_rnn_1_1step_CC_maskV_-1.0=0.68219894, learning_rate=0.001\n", + "Epoch 103/163 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38299164, rnn_1_1step_R2_maskV_-1.0=0.60378325, rnn_1_1step_CC_maskV_-1.0=0.78398627, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51911259, val_rnn_1_1step_R2_maskV_-1.0=0.40592226, val_rnn_1_1step_CC_maskV_-1.0=0.68955439, learning_rate=0.001\n", + "Epoch 120/163 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36200538, rnn_1_1step_R2_maskV_-1.0=0.62567514, rnn_1_1step_CC_maskV_-1.0=0.79710668, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52798432, val_rnn_1_1step_R2_maskV_-1.0=0.39518452, val_rnn_1_1step_CC_maskV_-1.0=0.69429356, learning_rate=0.001\n", + "Epoch 137/163 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.34424102, rnn_1_1step_R2_maskV_-1.0=0.64418709, rnn_1_1step_CC_maskV_-1.0=0.80822468, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53874201, val_rnn_1_1step_R2_maskV_-1.0=0.38119239, val_rnn_1_1step_CC_maskV_-1.0=0.6971432, learning_rate=0.001\n", + "Epoch 154/163 - loss=rnn_1_1step_loss=0.33658937, rnn_1_1step_R2_maskV_-1.0=0.6519295, rnn_1_1step_CC_maskV_-1.0=0.81387347, rnn_1_1step_MSE_maskV_-1.0=0.3365894, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50708967, val_rnn_1_1step_R2_maskV_-1.0=0.4199245, val_rnn_1_1step_CC_maskV_-1.0=0.70664978, learning_rate=0.001\n", + "Epoch 163/163 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.34132886, rnn_1_1step_R2_maskV_-1.0=0.64737332, rnn_1_1step_CC_maskV_-1.0=0.81184232, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4969368, val_rnn_1_1step_R2_maskV_-1.0=0.43364161, val_rnn_1_1step_CC_maskV_-1.0=0.70893061, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:50:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 18.99s\n", + "\u001b[32m2025-05-30 14:50:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.48176494)\n", + "\u001b[32m2025-05-30 14:50:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.357, R2_maskV_-1.0=0.643, CC_maskV_-1.0=0.804\n", + "\u001b[32m2025-05-30 14:50:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.463, R2_maskV_-1.0=0.482, CC_maskV_-1.0=0.725\n", + "\u001b[32m2025-05-30 14:50:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 14:50:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:50:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 135 (stopped at 150 epochs).\n", + "\u001b[32m2025-05-30 14:50:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/151 - loss=1.8417662, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.082207829, MSE_maskV_-1.0=1.8413929, val_loss=1.116353, val_CC_maskV_-1.0=0.1588162, val_MSE_maskV_-1.0=1.1143988, learning_rate=0.001\n", + "Epoch 17/151 - loss=0.75387466, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49598473, MSE_maskV_-1.0=0.75349033, val_loss=0.75733584, val_CC_maskV_-1.0=0.49408987, val_MSE_maskV_-1.0=0.75623846, learning_rate=0.001\n", + "Epoch 33/151 - loss=0.72400987, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52428097, MSE_maskV_-1.0=0.72385484, val_loss=0.73094797, val_CC_maskV_-1.0=0.51874536, val_MSE_maskV_-1.0=0.7303682, learning_rate=0.001\n", + "Epoch 49/151 - loss=0.7130751, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53465039, MSE_maskV_-1.0=0.71293861, val_loss=0.71938938, val_CC_maskV_-1.0=0.5290029, val_MSE_maskV_-1.0=0.71895492, learning_rate=0.001\n", + "Epoch 65/151 - loss=0.70842117, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53869057, MSE_maskV_-1.0=0.7086153, val_loss=0.7158227, val_CC_maskV_-1.0=0.53061903, val_MSE_maskV_-1.0=0.71584284, learning_rate=0.001\n", + "Epoch 81/151 - loss=0.70627576, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54095727, MSE_maskV_-1.0=0.70613575, val_loss=0.71306199, val_CC_maskV_-1.0=0.53327006, val_MSE_maskV_-1.0=0.71302629, learning_rate=0.001\n", + "Epoch 97/151 - loss=0.7051239, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54146838, MSE_maskV_-1.0=0.70447379, val_loss=0.71128553, val_CC_maskV_-1.0=0.53523016, val_MSE_maskV_-1.0=0.71108425, learning_rate=0.001\n", + "Epoch 113/151 - loss=0.70473003, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54187292, MSE_maskV_-1.0=0.70710146, val_loss=0.71156067, val_CC_maskV_-1.0=0.53530395, val_MSE_maskV_-1.0=0.71120566, learning_rate=0.001\n", + "Epoch 129/151 - loss=0.70440882, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54249787, MSE_maskV_-1.0=0.70412344, val_loss=0.71060109, val_CC_maskV_-1.0=0.53552091, val_MSE_maskV_-1.0=0.7105276, learning_rate=0.001\n", + "Epoch 145/151 - loss=0.70452029, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54205197, MSE_maskV_-1.0=0.704615, val_loss=0.71015489, val_CC_maskV_-1.0=0.53613847, val_MSE_maskV_-1.0=0.70975769, learning_rate=0.001\n", + "Epoch 151/151 - loss=0.70441437, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54221326, MSE_maskV_-1.0=0.70393479, val_loss=0.71030939, val_CC_maskV_-1.0=0.5360598, val_MSE_maskV_-1.0=0.70991117, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:50:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 36.22s\n", + "\u001b[32m2025-05-30 14:50:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:51:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 77 (stopped at 92 epochs).\n", + "\u001b[32m2025-05-30 14:51:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/93 - loss=2.1812296, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0469063, MSE_maskV_-1.0=2.1806684, val_loss=1.1827165, val_CC_maskV_-1.0=0.11298281, val_MSE_maskV_-1.0=1.1802292, learning_rate=0.001\n", + "Epoch 11/93 - loss=0.78357571, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46417874, MSE_maskV_-1.0=0.78397393, val_loss=0.78313792, val_CC_maskV_-1.0=0.46785644, val_MSE_maskV_-1.0=0.78211361, learning_rate=0.001\n", + "Epoch 21/93 - loss=0.7425192, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50767028, MSE_maskV_-1.0=0.74229354, val_loss=0.74433351, val_CC_maskV_-1.0=0.50632781, val_MSE_maskV_-1.0=0.7437548, learning_rate=0.001\n", + "Epoch 31/93 - loss=0.72502995, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52385753, MSE_maskV_-1.0=0.72521222, val_loss=0.7288689, val_CC_maskV_-1.0=0.520091, val_MSE_maskV_-1.0=0.72838736, learning_rate=0.001\n", + "Epoch 41/93 - loss=0.71651065, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53107518, MSE_maskV_-1.0=0.71661907, val_loss=0.72406864, val_CC_maskV_-1.0=0.52456522, val_MSE_maskV_-1.0=0.7238192, learning_rate=0.001\n", + "Epoch 51/93 - loss=0.711981, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53520864, MSE_maskV_-1.0=0.71151012, val_loss=0.71885127, val_CC_maskV_-1.0=0.52850389, val_MSE_maskV_-1.0=0.71865219, learning_rate=0.001\n", + "Epoch 61/93 - loss=0.70906216, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53799504, MSE_maskV_-1.0=0.70862132, val_loss=0.71362394, val_CC_maskV_-1.0=0.53352892, val_MSE_maskV_-1.0=0.71325773, learning_rate=0.001\n", + "Epoch 71/93 - loss=0.70723212, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5392068, MSE_maskV_-1.0=0.70826316, val_loss=0.71163154, val_CC_maskV_-1.0=0.53460419, val_MSE_maskV_-1.0=0.71169096, learning_rate=0.001\n", + "Epoch 81/93 - loss=0.70612407, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54110408, MSE_maskV_-1.0=0.70598, val_loss=0.71256632, val_CC_maskV_-1.0=0.53363174, val_MSE_maskV_-1.0=0.712578, learning_rate=0.001\n", + "Epoch 91/93 - loss=0.70526856, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54186398, MSE_maskV_-1.0=0.70549142, val_loss=0.71118927, val_CC_maskV_-1.0=0.53528559, val_MSE_maskV_-1.0=0.71090108, learning_rate=0.001\n", + "Epoch 93/93 - loss=0.70526665, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54154354, MSE_maskV_-1.0=0.70458072, val_loss=0.71119446, val_CC_maskV_-1.0=0.53536719, val_MSE_maskV_-1.0=0.71101516, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:51:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 22.70s\n", + "\u001b[32m2025-05-30 14:51:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.70891845)\n", + "\u001b[32m2025-05-30 14:51:19\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 681us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:51:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.703, R2_maskV_-1.0=0.298, CC_maskV_-1.0=0.545\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 730us/step\n", + "51/51 [==============================] - 0s 780us/step\n", + "84/84 [==============================] - 0s 640us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:51:20\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_ACz1HL64U_ErSV16\" (7/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_ACz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 14:51:20\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_ACy1HL64U_ErSV16\" (8/16)\n", + "\u001b[32m2025-05-30 14:51:20\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 14:51:20\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 14:51:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 14:51:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 14:51:20\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 14:51:20\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 14:51:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:51:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 133 (stopped at 148 epochs).\n", + "\u001b[32m2025-05-30 14:51:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/149 - loss=rnn_1step_loss=0.99862576, rnn_1step_R2_maskV_-1.0=-0.021254327, rnn_1step_CC_maskV_-1.0=0.029209768, rnn_1step_MSE_maskV_-1.0=0.9986257, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96046942, val_rnn_1step_R2_maskV_-1.0=-0.083000958, val_rnn_1step_CC_maskV_-1.0=0.1393124, learning_rate=0.001\n", + "Epoch 16/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.76254433, rnn_1step_R2_maskV_-1.0=0.21489008, rnn_1step_CC_maskV_-1.0=0.49159968, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.7525546, val_rnn_1step_R2_maskV_-1.0=0.14068276, val_rnn_1step_CC_maskV_-1.0=0.46588677, learning_rate=0.001\n", + "Epoch 31/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.57614344, rnn_1step_R2_maskV_-1.0=0.40323234, rnn_1step_CC_maskV_-1.0=0.64931983, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.67538595, val_rnn_1step_R2_maskV_-1.0=0.23100784, val_rnn_1step_CC_maskV_-1.0=0.55754584, learning_rate=0.001\n", + "Epoch 46/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.52875221, rnn_1step_R2_maskV_-1.0=0.45281792, rnn_1step_CC_maskV_-1.0=0.6847707, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64964461, val_rnn_1step_R2_maskV_-1.0=0.26045305, val_rnn_1step_CC_maskV_-1.0=0.58294767, learning_rate=0.001\n", + "Epoch 61/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.49969086, rnn_1step_R2_maskV_-1.0=0.48319411, rnn_1step_CC_maskV_-1.0=0.70599335, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63140184, val_rnn_1step_R2_maskV_-1.0=0.28074414, val_rnn_1step_CC_maskV_-1.0=0.60028565, learning_rate=0.001\n", + "Epoch 76/149 - loss=rnn_1step_loss=0.47176847, rnn_1step_R2_maskV_-1.0=0.5118503, rnn_1step_CC_maskV_-1.0=0.72615439, rnn_1step_MSE_maskV_-1.0=0.47176844, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6047613, val_rnn_1step_R2_maskV_-1.0=0.31058392, val_rnn_1step_CC_maskV_-1.0=0.61806875, learning_rate=0.001\n", + "Epoch 91/149 - loss=rnn_1step_loss=0.43456659, rnn_1step_R2_maskV_-1.0=0.5504033, rnn_1step_CC_maskV_-1.0=0.75023359, rnn_1step_MSE_maskV_-1.0=0.43456662, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58195442, val_rnn_1step_R2_maskV_-1.0=0.33394235, val_rnn_1step_CC_maskV_-1.0=0.63842326, learning_rate=0.001\n", + "Epoch 106/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41167304, rnn_1step_R2_maskV_-1.0=0.5740031, rnn_1step_CC_maskV_-1.0=0.7652781, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57506919, val_rnn_1step_R2_maskV_-1.0=0.34022439, val_rnn_1step_CC_maskV_-1.0=0.64722329, learning_rate=0.001\n", + "Epoch 121/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40066421, rnn_1step_R2_maskV_-1.0=0.58495265, rnn_1step_CC_maskV_-1.0=0.77296895, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56300282, val_rnn_1step_R2_maskV_-1.0=0.35365748, val_rnn_1step_CC_maskV_-1.0=0.65369415, learning_rate=0.001\n", + "Epoch 136/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40986609, rnn_1step_R2_maskV_-1.0=0.5756067, rnn_1step_CC_maskV_-1.0=0.76882672, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5886665, val_rnn_1step_R2_maskV_-1.0=0.32252812, val_rnn_1step_CC_maskV_-1.0=0.640423, learning_rate=0.001\n", + "Epoch 149/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37813959, rnn_1step_R2_maskV_-1.0=0.60848641, rnn_1step_CC_maskV_-1.0=0.78702521, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55793422, val_rnn_1step_R2_maskV_-1.0=0.3603031, val_rnn_1step_CC_maskV_-1.0=0.65967405, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:51:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 17.29s\n", + "\u001b[32m2025-05-30 14:51:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:51:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 120 (stopped at 135 epochs).\n", + "\u001b[32m2025-05-30 14:51:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/136 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.99800539, rnn_1_1step_R2_maskV_-1.0=-0.020775992, rnn_1_1step_CC_maskV_-1.0=0.041253958, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.95908117, val_rnn_1_1step_R2_maskV_-1.0=-0.081635773, val_rnn_1_1step_CC_maskV_-1.0=0.15724325, learning_rate=0.001\n", + "Epoch 15/136 - loss=rnn_1_1step_loss=0.70943755, rnn_1_1step_R2_maskV_-1.0=0.26827383, rnn_1_1step_CC_maskV_-1.0=0.54129481, rnn_1_1step_MSE_maskV_-1.0=0.70943749, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.717664, val_rnn_1_1step_R2_maskV_-1.0=0.18323854, val_rnn_1_1step_CC_maskV_-1.0=0.50363702, learning_rate=0.001\n", + "Epoch 29/136 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.57225186, rnn_1_1step_R2_maskV_-1.0=0.40771651, rnn_1_1step_CC_maskV_-1.0=0.65244776, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.66601795, val_rnn_1_1step_R2_maskV_-1.0=0.24219434, val_rnn_1_1step_CC_maskV_-1.0=0.56499237, learning_rate=0.001\n", + "Epoch 43/136 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.5310055, rnn_1_1step_R2_maskV_-1.0=0.45036983, rnn_1_1step_CC_maskV_-1.0=0.68334043, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6453318, val_rnn_1_1step_R2_maskV_-1.0=0.26540658, val_rnn_1_1step_CC_maskV_-1.0=0.58653861, learning_rate=0.001\n", + "Epoch 57/136 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.50281698, rnn_1_1step_R2_maskV_-1.0=0.4796164, rnn_1_1step_CC_maskV_-1.0=0.70380437, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63346815, val_rnn_1_1step_R2_maskV_-1.0=0.27788544, val_rnn_1_1step_CC_maskV_-1.0=0.59909081, learning_rate=0.001\n", + "Epoch 71/136 - loss=rnn_1_1step_loss=0.47596112, rnn_1_1step_R2_maskV_-1.0=0.5073756, rnn_1_1step_CC_maskV_-1.0=0.72219688, rnn_1_1step_MSE_maskV_-1.0=0.47596115, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62585217, val_rnn_1_1step_R2_maskV_-1.0=0.28544891, val_rnn_1_1step_CC_maskV_-1.0=0.60664666, learning_rate=0.001\n", + "Epoch 85/136 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44885898, rnn_1_1step_R2_maskV_-1.0=0.53500336, rnn_1_1step_CC_maskV_-1.0=0.7408492, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59983552, val_rnn_1_1step_R2_maskV_-1.0=0.3143065, val_rnn_1_1step_CC_maskV_-1.0=0.62456173, learning_rate=0.001\n", + "Epoch 99/136 - loss=rnn_1_1step_loss=0.43093562, rnn_1_1step_R2_maskV_-1.0=0.55325317, rnn_1_1step_CC_maskV_-1.0=0.75228924, rnn_1_1step_MSE_maskV_-1.0=0.43093559, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57884383, val_rnn_1_1step_R2_maskV_-1.0=0.3362582, val_rnn_1_1step_CC_maskV_-1.0=0.64285326, learning_rate=0.001\n", + "Epoch 113/136 - loss=rnn_1_1step_loss=0.40674806, rnn_1_1step_R2_maskV_-1.0=0.57819492, rnn_1_1step_CC_maskV_-1.0=0.7688601, rnn_1_1step_MSE_maskV_-1.0=0.40674803, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56199205, val_rnn_1_1step_R2_maskV_-1.0=0.35532832, val_rnn_1_1step_CC_maskV_-1.0=0.65437281, learning_rate=0.001\n", + "Epoch 127/136 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38317177, rnn_1_1step_R2_maskV_-1.0=0.60240185, rnn_1_1step_CC_maskV_-1.0=0.78331321, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56598419, val_rnn_1_1step_R2_maskV_-1.0=0.3513487, val_rnn_1_1step_CC_maskV_-1.0=0.6552037, learning_rate=0.001\n", + "Epoch 136/136 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.37585041, rnn_1_1step_R2_maskV_-1.0=0.60963953, rnn_1_1step_CC_maskV_-1.0=0.78905034, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55498964, val_rnn_1_1step_R2_maskV_-1.0=0.36454335, val_rnn_1_1step_CC_maskV_-1.0=0.66049927, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:51:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.98s\n", + "\u001b[32m2025-05-30 14:51:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.53805923)\n", + "\u001b[32m2025-05-30 14:51:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.375, R2_maskV_-1.0=0.625, CC_maskV_-1.0=0.793\n", + "\u001b[32m2025-05-30 14:51:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.521, R2_maskV_-1.0=0.417, CC_maskV_-1.0=0.684\n", + "\u001b[32m2025-05-30 14:51:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 14:51:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:52:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 141 (stopped at 156 epochs).\n", + "\u001b[32m2025-05-30 14:52:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/157 - loss=1.0435284, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.16869874, MSE_maskV_-1.0=1.0449873, val_loss=0.91805041, val_CC_maskV_-1.0=0.28890219, val_MSE_maskV_-1.0=0.91682982, learning_rate=0.001\n", + "Epoch 17/157 - loss=0.6660502, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57590532, MSE_maskV_-1.0=0.66578174, val_loss=0.68432814, val_CC_maskV_-1.0=0.56013095, val_MSE_maskV_-1.0=0.68262267, learning_rate=0.001\n", + "Epoch 33/157 - loss=0.63838309, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59810811, MSE_maskV_-1.0=0.6382069, val_loss=0.6623292, val_CC_maskV_-1.0=0.57864499, val_MSE_maskV_-1.0=0.66118562, learning_rate=0.001\n", + "Epoch 49/157 - loss=0.62431794, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61026812, MSE_maskV_-1.0=0.62447804, val_loss=0.65397626, val_CC_maskV_-1.0=0.58593357, val_MSE_maskV_-1.0=0.65292865, learning_rate=0.001\n", + "Epoch 65/157 - loss=0.61636561, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61536342, MSE_maskV_-1.0=0.61660665, val_loss=0.64755416, val_CC_maskV_-1.0=0.59161389, val_MSE_maskV_-1.0=0.6464721, learning_rate=0.001\n", + "Epoch 81/157 - loss=0.61042386, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62165326, MSE_maskV_-1.0=0.60995424, val_loss=0.64660484, val_CC_maskV_-1.0=0.59375876, val_MSE_maskV_-1.0=0.6453743, learning_rate=0.001\n", + "Epoch 97/157 - loss=0.60624892, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62474835, MSE_maskV_-1.0=0.60570157, val_loss=0.64095968, val_CC_maskV_-1.0=0.59816092, val_MSE_maskV_-1.0=0.63957506, learning_rate=0.001\n", + "Epoch 113/157 - loss=0.60263568, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62746787, MSE_maskV_-1.0=0.60389262, val_loss=0.63981104, val_CC_maskV_-1.0=0.59952796, val_MSE_maskV_-1.0=0.63856471, learning_rate=0.001\n", + "Epoch 129/157 - loss=0.59957463, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62980258, MSE_maskV_-1.0=0.59938794, val_loss=0.63745099, val_CC_maskV_-1.0=0.6012826, val_MSE_maskV_-1.0=0.63622022, learning_rate=0.001\n", + "Epoch 145/157 - loss=0.59682351, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63147575, MSE_maskV_-1.0=0.5970391, val_loss=0.63716847, val_CC_maskV_-1.0=0.60232788, val_MSE_maskV_-1.0=0.63570338, learning_rate=0.001\n", + "Epoch 157/157 - loss=0.59536695, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63219941, MSE_maskV_-1.0=0.59496987, val_loss=0.63500983, val_CC_maskV_-1.0=0.60384208, val_MSE_maskV_-1.0=0.63383955, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:52:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 40.54s\n", + "\u001b[32m2025-05-30 14:52:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:53:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 117 (stopped at 132 epochs).\n", + "\u001b[32m2025-05-30 14:53:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/133 - loss=1.0491358, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.20045885, MSE_maskV_-1.0=1.0505683, val_loss=0.90534937, val_CC_maskV_-1.0=0.31196564, val_MSE_maskV_-1.0=0.90323025, learning_rate=0.001\n", + "Epoch 15/133 - loss=0.6746943, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56884813, MSE_maskV_-1.0=0.67490679, val_loss=0.68947983, val_CC_maskV_-1.0=0.55589962, val_MSE_maskV_-1.0=0.68756157, learning_rate=0.001\n", + "Epoch 29/133 - loss=0.64621514, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59276044, MSE_maskV_-1.0=0.64582986, val_loss=0.66797483, val_CC_maskV_-1.0=0.57418764, val_MSE_maskV_-1.0=0.66627508, learning_rate=0.001\n", + "Epoch 43/133 - loss=0.63043934, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60577106, MSE_maskV_-1.0=0.63056421, val_loss=0.65870428, val_CC_maskV_-1.0=0.58364391, val_MSE_maskV_-1.0=0.65672684, learning_rate=0.001\n", + "Epoch 57/133 - loss=0.61993825, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61364174, MSE_maskV_-1.0=0.62034798, val_loss=0.65198392, val_CC_maskV_-1.0=0.58881199, val_MSE_maskV_-1.0=0.65015501, learning_rate=0.001\n", + "Epoch 71/133 - loss=0.61298156, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61946517, MSE_maskV_-1.0=0.61310661, val_loss=0.64982796, val_CC_maskV_-1.0=0.59194028, val_MSE_maskV_-1.0=0.64789575, learning_rate=0.001\n", + "Epoch 85/133 - loss=0.60859662, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62264633, MSE_maskV_-1.0=0.60851198, val_loss=0.64467424, val_CC_maskV_-1.0=0.59527081, val_MSE_maskV_-1.0=0.64239597, learning_rate=0.001\n", + "Epoch 99/133 - loss=0.60468471, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6256845, MSE_maskV_-1.0=0.60446006, val_loss=0.64390355, val_CC_maskV_-1.0=0.59650755, val_MSE_maskV_-1.0=0.64147395, learning_rate=0.001\n", + "Epoch 113/133 - loss=0.60192031, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62829262, MSE_maskV_-1.0=0.60319734, val_loss=0.64172882, val_CC_maskV_-1.0=0.597857, val_MSE_maskV_-1.0=0.63915569, learning_rate=0.001\n", + "Epoch 127/133 - loss=0.59976864, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62817788, MSE_maskV_-1.0=0.6007269, val_loss=0.6407904, val_CC_maskV_-1.0=0.59817839, val_MSE_maskV_-1.0=0.63810706, learning_rate=0.001\n", + "Epoch 133/133 - loss=0.59896851, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62994629, MSE_maskV_-1.0=0.59852272, val_loss=0.641352, val_CC_maskV_-1.0=0.59832698, val_MSE_maskV_-1.0=0.63892281, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:53:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 34.34s\n", + "\u001b[32m2025-05-30 14:53:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.63398862)\n", + "\u001b[32m2025-05-30 14:53:10\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 779us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:53:11\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.594, R2_maskV_-1.0=0.408, CC_maskV_-1.0=0.637\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 720us/step\n", + "51/51 [==============================] - 0s 763us/step\n", + "84/84 [==============================] - 0s 718us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:53:11\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_ACy1HL64U_ErSV16\" (8/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_ACy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 14:53:11\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_KCz1HL64U_ErSV16\" (9/16)\n", + "\u001b[32m2025-05-30 14:53:11\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 14:53:11\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 14:53:11\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 14:53:12\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 14:53:12\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 14:53:12\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 14:53:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:53:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 86 (stopped at 101 epochs).\n", + "\u001b[32m2025-05-30 14:53:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/102 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.99941921, rnn_1step_R2_maskV_-1.0=-0.022336632, rnn_1step_CC_maskV_-1.0=0.023332849, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96525365, val_rnn_1step_R2_maskV_-1.0=-0.0879962, val_rnn_1step_CC_maskV_-1.0=0.29212099, learning_rate=0.001\n", + "Epoch 12/102 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.83844471, rnn_1step_R2_maskV_-1.0=0.13803527, rnn_1step_CC_maskV_-1.0=0.40764618, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.79207182, val_rnn_1step_R2_maskV_-1.0=0.097814679, val_rnn_1step_CC_maskV_-1.0=0.40786055, learning_rate=0.001\n", + "Epoch 23/102 - loss=rnn_1step_loss=0.59609133, rnn_1step_R2_maskV_-1.0=0.38125172, rnn_1step_CC_maskV_-1.0=0.63519531, rnn_1step_MSE_maskV_-1.0=0.59609139, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.66250551, val_rnn_1step_R2_maskV_-1.0=0.24390821, val_rnn_1step_CC_maskV_-1.0=0.56328917, learning_rate=0.001\n", + "Epoch 34/102 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.49011931, rnn_1step_R2_maskV_-1.0=0.49098384, rnn_1step_CC_maskV_-1.0=0.71236306, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59262294, val_rnn_1step_R2_maskV_-1.0=0.32630962, val_rnn_1step_CC_maskV_-1.0=0.62640446, learning_rate=0.001\n", + "Epoch 45/102 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42149988, rnn_1step_R2_maskV_-1.0=0.56203479, rnn_1step_CC_maskV_-1.0=0.75886476, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52908403, val_rnn_1step_R2_maskV_-1.0=0.39669314, val_rnn_1step_CC_maskV_-1.0=0.6736837, learning_rate=0.001\n", + "Epoch 56/102 - loss=rnn_1step_loss=0.36443624, rnn_1step_R2_maskV_-1.0=0.62197483, rnn_1step_CC_maskV_-1.0=0.79569149, rnn_1step_MSE_maskV_-1.0=0.36443621, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49372435, val_rnn_1step_R2_maskV_-1.0=0.437289, val_rnn_1step_CC_maskV_-1.0=0.70075214, learning_rate=0.001\n", + "Epoch 67/102 - loss=rnn_1step_loss=0.32837889, rnn_1step_R2_maskV_-1.0=0.65941983, rnn_1step_CC_maskV_-1.0=0.81810522, rnn_1step_MSE_maskV_-1.0=0.32837892, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48855281, val_rnn_1step_R2_maskV_-1.0=0.44314665, val_rnn_1step_CC_maskV_-1.0=0.70586163, learning_rate=0.001\n", + "Epoch 78/102 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30387941, rnn_1step_R2_maskV_-1.0=0.6849829, rnn_1step_CC_maskV_-1.0=0.8329587, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48154736, val_rnn_1step_R2_maskV_-1.0=0.45148149, val_rnn_1step_CC_maskV_-1.0=0.70874184, learning_rate=0.001\n", + "Epoch 89/102 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.28089035, rnn_1step_R2_maskV_-1.0=0.70903343, rnn_1step_CC_maskV_-1.0=0.84738499, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48422173, val_rnn_1step_R2_maskV_-1.0=0.44797525, val_rnn_1step_CC_maskV_-1.0=0.71060741, learning_rate=0.001\n", + "Epoch 100/102 - loss=rnn_1step_loss=0.26286468, rnn_1step_R2_maskV_-1.0=0.72772127, rnn_1step_CC_maskV_-1.0=0.85737389, rnn_1step_MSE_maskV_-1.0=0.26286465, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4950169, val_rnn_1step_R2_maskV_-1.0=0.43440846, val_rnn_1step_CC_maskV_-1.0=0.70869237, learning_rate=0.001\n", + "Epoch 102/102 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.260111, rnn_1step_R2_maskV_-1.0=0.73070216, rnn_1step_CC_maskV_-1.0=0.85960209, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48479548, val_rnn_1step_R2_maskV_-1.0=0.44704825, val_rnn_1step_CC_maskV_-1.0=0.71210486, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:53:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.12s\n", + "\u001b[32m2025-05-30 14:53:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:53:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 160 (stopped at 175 epochs).\n", + "\u001b[32m2025-05-30 14:53:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/176 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.99953252, rnn_1_1step_R2_maskV_-1.0=-0.022457451, rnn_1_1step_CC_maskV_-1.0=-0.021053798, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.9659031, val_rnn_1_1step_R2_maskV_-1.0=-0.088762328, val_rnn_1_1step_CC_maskV_-1.0=0.20826061, learning_rate=0.001\n", + "Epoch 19/176 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.72069263, rnn_1_1step_R2_maskV_-1.0=0.25273651, rnn_1_1step_CC_maskV_-1.0=0.5283165, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.74759436, val_rnn_1_1step_R2_maskV_-1.0=0.14757267, val_rnn_1_1step_CC_maskV_-1.0=0.47386432, learning_rate=0.001\n", + "Epoch 37/176 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.57362431, rnn_1_1step_R2_maskV_-1.0=0.40217519, rnn_1_1step_CC_maskV_-1.0=0.6511026, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.67117387, val_rnn_1_1step_R2_maskV_-1.0=0.24124448, val_rnn_1_1step_CC_maskV_-1.0=0.5526973, learning_rate=0.001\n", + "Epoch 55/176 - loss=rnn_1_1step_loss=0.44800234, rnn_1_1step_R2_maskV_-1.0=0.53384435, rnn_1_1step_CC_maskV_-1.0=0.74087089, rnn_1_1step_MSE_maskV_-1.0=0.44800228, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57618409, val_rnn_1_1step_R2_maskV_-1.0=0.34750929, val_rnn_1_1step_CC_maskV_-1.0=0.63812691, learning_rate=0.001\n", + "Epoch 73/176 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39213386, rnn_1_1step_R2_maskV_-1.0=0.59052277, rnn_1_1step_CC_maskV_-1.0=0.77986598, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53021544, val_rnn_1_1step_R2_maskV_-1.0=0.3957431, val_rnn_1_1step_CC_maskV_-1.0=0.67555887, learning_rate=0.001\n", + "Epoch 91/176 - loss=rnn_1_1step_loss=0.32643667, rnn_1_1step_R2_maskV_-1.0=0.65988886, rnn_1_1step_CC_maskV_-1.0=0.81947607, rnn_1_1step_MSE_maskV_-1.0=0.32643664, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51079977, val_rnn_1_1step_R2_maskV_-1.0=0.41689247, val_rnn_1_1step_CC_maskV_-1.0=0.69371027, learning_rate=0.001\n", + "Epoch 109/176 - loss=rnn_1_1step_loss=0.29499504, rnn_1_1step_R2_maskV_-1.0=0.69283277, rnn_1_1step_CC_maskV_-1.0=0.83837968, rnn_1_1step_MSE_maskV_-1.0=0.29499501, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50617868, val_rnn_1_1step_R2_maskV_-1.0=0.42176718, val_rnn_1_1step_CC_maskV_-1.0=0.7012347, learning_rate=0.001\n", + "Epoch 127/176 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.27292779, rnn_1_1step_R2_maskV_-1.0=0.71610379, rnn_1_1step_CC_maskV_-1.0=0.85181606, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4982495, val_rnn_1_1step_R2_maskV_-1.0=0.43109581, val_rnn_1_1step_CC_maskV_-1.0=0.70641935, learning_rate=0.001\n", + "Epoch 145/176 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.25188819, rnn_1_1step_R2_maskV_-1.0=0.7379725, rnn_1_1step_CC_maskV_-1.0=0.8640815, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49000528, val_rnn_1_1step_R2_maskV_-1.0=0.44082296, val_rnn_1_1step_CC_maskV_-1.0=0.71157789, learning_rate=0.001\n", + "Epoch 163/176 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.24097963, rnn_1_1step_R2_maskV_-1.0=0.74933624, rnn_1_1step_CC_maskV_-1.0=0.87059486, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48789135, val_rnn_1_1step_R2_maskV_-1.0=0.44249463, val_rnn_1_1step_CC_maskV_-1.0=0.71292728, learning_rate=0.001\n", + "Epoch 176/176 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.22776353, rnn_1_1step_R2_maskV_-1.0=0.76312071, rnn_1_1step_CC_maskV_-1.0=0.8781749, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4889493, val_rnn_1_1step_R2_maskV_-1.0=0.44182003, val_rnn_1_1step_CC_maskV_-1.0=0.71361506, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:53:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 19.04s\n", + "\u001b[32m2025-05-30 14:53:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.47868133)\n", + "\u001b[32m2025-05-30 14:53:44\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.228, R2_maskV_-1.0=0.771, CC_maskV_-1.0=0.878\n", + "\u001b[32m2025-05-30 14:53:44\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.465, R2_maskV_-1.0=0.482, CC_maskV_-1.0=0.735\n", + "\u001b[32m2025-05-30 14:53:44\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 14:53:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:55:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 408 (stopped at 423 epochs).\n", + "\u001b[32m2025-05-30 14:55:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/424 - loss=3.6687651, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.010349452, MSE_maskV_-1.0=3.6634691, val_loss=1.3976339, val_CC_maskV_-1.0=0.02657051, val_MSE_maskV_-1.0=1.3907942, learning_rate=0.001\n", + "Epoch 44/424 - loss=0.8632831, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37040779, MSE_maskV_-1.0=0.86535025, val_loss=0.86390501, val_CC_maskV_-1.0=0.37762991, val_MSE_maskV_-1.0=0.86291003, learning_rate=0.001\n", + "Epoch 87/424 - loss=0.84486371, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39448419, MSE_maskV_-1.0=0.84422463, val_loss=0.84595388, val_CC_maskV_-1.0=0.40062791, val_MSE_maskV_-1.0=0.84523666, learning_rate=0.001\n", + "Epoch 130/424 - loss=0.83188838, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41115302, MSE_maskV_-1.0=0.83456391, val_loss=0.83393949, val_CC_maskV_-1.0=0.41667512, val_MSE_maskV_-1.0=0.83352113, learning_rate=0.001\n", + "Epoch 173/424 - loss=0.82292932, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42192996, MSE_maskV_-1.0=0.82212627, val_loss=0.82480717, val_CC_maskV_-1.0=0.42797017, val_MSE_maskV_-1.0=0.82408965, learning_rate=0.001\n", + "Epoch 216/424 - loss=0.81625879, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43046939, MSE_maskV_-1.0=0.81540978, val_loss=0.81752253, val_CC_maskV_-1.0=0.4369843, val_MSE_maskV_-1.0=0.81673396, learning_rate=0.001\n", + "Epoch 259/424 - loss=0.81002039, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43807098, MSE_maskV_-1.0=0.80982965, val_loss=0.81071252, val_CC_maskV_-1.0=0.44346929, val_MSE_maskV_-1.0=0.81046408, learning_rate=0.001\n", + "Epoch 302/424 - loss=0.80464947, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44344914, MSE_maskV_-1.0=0.80387348, val_loss=0.80690974, val_CC_maskV_-1.0=0.44826335, val_MSE_maskV_-1.0=0.8065033, learning_rate=0.001\n", + "Epoch 345/424 - loss=0.80080199, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44820866, MSE_maskV_-1.0=0.80061758, val_loss=0.80438209, val_CC_maskV_-1.0=0.44985154, val_MSE_maskV_-1.0=0.80478042, learning_rate=0.001\n", + "Epoch 388/424 - loss=0.79707289, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45202109, MSE_maskV_-1.0=0.79664379, val_loss=0.80020607, val_CC_maskV_-1.0=0.45594141, val_MSE_maskV_-1.0=0.7988559, learning_rate=0.001\n", + "Epoch 424/424 - loss=0.79412425, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45564896, MSE_maskV_-1.0=0.7934894, val_loss=0.7969538, val_CC_maskV_-1.0=0.45915958, val_MSE_maskV_-1.0=0.7963028, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:55:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 99.61s\n", + "\u001b[32m2025-05-30 14:55:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:57:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 408 (stopped at 423 epochs).\n", + "\u001b[32m2025-05-30 14:57:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/424 - loss=3.2177825, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=-0.0010385963, MSE_maskV_-1.0=3.2136421, val_loss=1.4352504, val_CC_maskV_-1.0=0.0045659523, val_MSE_maskV_-1.0=1.4368271, learning_rate=0.001\n", + "Epoch 44/424 - loss=0.85984319, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37530681, MSE_maskV_-1.0=0.86186022, val_loss=0.86009866, val_CC_maskV_-1.0=0.38292617, val_MSE_maskV_-1.0=0.85938311, learning_rate=0.001\n", + "Epoch 87/424 - loss=0.84282517, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39709362, MSE_maskV_-1.0=0.842188, val_loss=0.84354293, val_CC_maskV_-1.0=0.40366027, val_MSE_maskV_-1.0=0.84302676, learning_rate=0.001\n", + "Epoch 130/424 - loss=0.83055198, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41281784, MSE_maskV_-1.0=0.83327526, val_loss=0.83209318, val_CC_maskV_-1.0=0.41886362, val_MSE_maskV_-1.0=0.83182293, learning_rate=0.001\n", + "Epoch 173/424 - loss=0.82193166, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42309776, MSE_maskV_-1.0=0.82115179, val_loss=0.82321149, val_CC_maskV_-1.0=0.42980751, val_MSE_maskV_-1.0=0.82270867, learning_rate=0.001\n", + "Epoch 216/424 - loss=0.81557655, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43121204, MSE_maskV_-1.0=0.81472993, val_loss=0.81618464, val_CC_maskV_-1.0=0.43847424, val_MSE_maskV_-1.0=0.81555581, learning_rate=0.001\n", + "Epoch 259/424 - loss=0.80954993, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43857169, MSE_maskV_-1.0=0.8093648, val_loss=0.80966794, val_CC_maskV_-1.0=0.44460449, val_MSE_maskV_-1.0=0.80959296, learning_rate=0.001\n", + "Epoch 302/424 - loss=0.80431086, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44385111, MSE_maskV_-1.0=0.80351484, val_loss=0.80599701, val_CC_maskV_-1.0=0.44918433, val_MSE_maskV_-1.0=0.80577505, learning_rate=0.001\n", + "Epoch 345/424 - loss=0.80051458, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44849256, MSE_maskV_-1.0=0.8003273, val_loss=0.80356961, val_CC_maskV_-1.0=0.45075196, val_MSE_maskV_-1.0=0.80411696, learning_rate=0.001\n", + "Epoch 388/424 - loss=0.79685801, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45226258, MSE_maskV_-1.0=0.79641229, val_loss=0.79952866, val_CC_maskV_-1.0=0.45663792, val_MSE_maskV_-1.0=0.79828697, learning_rate=0.001\n", + "Epoch 424/424 - loss=0.79399306, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45578364, MSE_maskV_-1.0=0.79334515, val_loss=0.79621518, val_CC_maskV_-1.0=0.45993271, val_MSE_maskV_-1.0=0.79569918, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:57:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 100.13s\n", + "\u001b[32m2025-05-30 14:57:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.79367626)\n", + "\u001b[32m2025-05-30 14:57:04\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 746us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:57:04\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.794, R2_maskV_-1.0=0.206, CC_maskV_-1.0=0.455\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 735us/step\n", + "51/51 [==============================] - 0s 725us/step\n", + "84/84 [==============================] - 0s 670us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:57:05\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_KCz1HL64U_ErSV16\" (9/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_KCz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 14:57:05\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_KCy1HL64U_ErSV16\" (10/16)\n", + "\u001b[32m2025-05-30 14:57:05\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 14:57:05\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 14:57:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 14:57:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 14:57:05\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 14:57:05\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 14:57:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:57:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 69 (stopped at 84 epochs).\n", + "\u001b[32m2025-05-30 14:57:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/85 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.99874878, rnn_1step_R2_maskV_-1.0=-0.021671765, rnn_1step_CC_maskV_-1.0=0.099282309, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96422261, val_rnn_1step_R2_maskV_-1.0=-0.086847395, val_rnn_1step_CC_maskV_-1.0=0.20691746, learning_rate=0.001\n", + "Epoch 10/85 - loss=rnn_1step_loss=0.85349178, rnn_1step_R2_maskV_-1.0=0.12532686, rnn_1step_CC_maskV_-1.0=0.4204188, rnn_1step_MSE_maskV_-1.0=0.85349184, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.81521207, val_rnn_1step_R2_maskV_-1.0=0.073032469, val_rnn_1step_CC_maskV_-1.0=0.4064016, learning_rate=0.001\n", + "Epoch 19/85 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.64510661, rnn_1step_R2_maskV_-1.0=0.33030429, rnn_1step_CC_maskV_-1.0=0.59571999, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.68693429, val_rnn_1step_R2_maskV_-1.0=0.21554673, val_rnn_1step_CC_maskV_-1.0=0.54858488, learning_rate=0.001\n", + "Epoch 28/85 - loss=rnn_1step_loss=0.54107529, rnn_1step_R2_maskV_-1.0=0.43855539, rnn_1step_CC_maskV_-1.0=0.67755413, rnn_1step_MSE_maskV_-1.0=0.54107535, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63423496, val_rnn_1step_R2_maskV_-1.0=0.27784956, val_rnn_1step_CC_maskV_-1.0=0.5932191, learning_rate=0.001\n", + "Epoch 37/85 - loss=rnn_1step_loss=0.46524397, rnn_1step_R2_maskV_-1.0=0.51876372, rnn_1step_CC_maskV_-1.0=0.73043442, rnn_1step_MSE_maskV_-1.0=0.465244, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6026656, val_rnn_1step_R2_maskV_-1.0=0.31546766, val_rnn_1step_CC_maskV_-1.0=0.6241256, learning_rate=0.001\n", + "Epoch 46/85 - loss=rnn_1step_loss=0.39893317, rnn_1step_R2_maskV_-1.0=0.58876878, rnn_1step_CC_maskV_-1.0=0.77460176, rnn_1step_MSE_maskV_-1.0=0.39893314, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5582127, val_rnn_1step_R2_maskV_-1.0=0.3647278, val_rnn_1step_CC_maskV_-1.0=0.6604203, learning_rate=0.001\n", + "Epoch 55/85 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33650032, rnn_1step_R2_maskV_-1.0=0.65309668, rnn_1step_CC_maskV_-1.0=0.81391627, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51529312, val_rnn_1step_R2_maskV_-1.0=0.41167885, val_rnn_1step_CC_maskV_-1.0=0.69554412, learning_rate=0.001\n", + "Epoch 64/85 - loss=rnn_1step_loss=0.29956731, rnn_1step_R2_maskV_-1.0=0.69089717, rnn_1step_CC_maskV_-1.0=0.83603793, rnn_1step_MSE_maskV_-1.0=0.29956734, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49890134, val_rnn_1step_R2_maskV_-1.0=0.43036622, val_rnn_1step_CC_maskV_-1.0=0.71069854, learning_rate=0.001\n", + "Epoch 73/85 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27905592, rnn_1step_R2_maskV_-1.0=0.71202558, rnn_1step_CC_maskV_-1.0=0.84802544, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49782017, val_rnn_1step_R2_maskV_-1.0=0.43120521, val_rnn_1step_CC_maskV_-1.0=0.71395719, learning_rate=0.001\n", + "Epoch 82/85 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.2656472, rnn_1step_R2_maskV_-1.0=0.725757, rnn_1step_CC_maskV_-1.0=0.85577345, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49909034, val_rnn_1step_R2_maskV_-1.0=0.42950147, val_rnn_1step_CC_maskV_-1.0=0.7147001, learning_rate=0.001\n", + "Epoch 85/85 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.26209822, rnn_1step_R2_maskV_-1.0=0.72938722, rnn_1step_CC_maskV_-1.0=0.85783279, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49949583, val_rnn_1step_R2_maskV_-1.0=0.42895269, val_rnn_1step_CC_maskV_-1.0=0.714809, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:57:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 9.52s\n", + "\u001b[32m2025-05-30 14:57:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:57:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 85 (stopped at 100 epochs).\n", + "\u001b[32m2025-05-30 14:57:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/101 - loss=rnn_1_1step_loss=0.9991892, rnn_1_1step_R2_maskV_-1.0=-0.022128843, rnn_1_1step_CC_maskV_-1.0=0.036259547, rnn_1_1step_MSE_maskV_-1.0=0.99918926, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96480864, val_rnn_1_1step_R2_maskV_-1.0=-0.087677374, val_rnn_1_1step_CC_maskV_-1.0=0.2694647, learning_rate=0.001\n", + "Epoch 12/101 - loss=rnn_1_1step_loss=0.80942804, rnn_1_1step_R2_maskV_-1.0=0.16929366, rnn_1_1step_CC_maskV_-1.0=0.43740284, rnn_1_1step_MSE_maskV_-1.0=0.8094281, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.78371567, val_rnn_1_1step_R2_maskV_-1.0=0.10830462, val_rnn_1_1step_CC_maskV_-1.0=0.44007388, learning_rate=0.001\n", + "Epoch 23/101 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.62712795, rnn_1_1step_R2_maskV_-1.0=0.3517932, rnn_1_1step_CC_maskV_-1.0=0.61246598, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.67096704, val_rnn_1_1step_R2_maskV_-1.0=0.23187621, val_rnn_1_1step_CC_maskV_-1.0=0.55902094, learning_rate=0.001\n", + "Epoch 34/101 - loss=rnn_1_1step_loss=0.51989961, rnn_1_1step_R2_maskV_-1.0=0.46188921, rnn_1_1step_CC_maskV_-1.0=0.69337261, rnn_1_1step_MSE_maskV_-1.0=0.51989955, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62100416, val_rnn_1_1step_R2_maskV_-1.0=0.2901502, val_rnn_1_1step_CC_maskV_-1.0=0.60668075, learning_rate=0.001\n", + "Epoch 45/101 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44172895, rnn_1_1step_R2_maskV_-1.0=0.54365331, rnn_1_1step_CC_maskV_-1.0=0.74675715, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57970273, val_rnn_1_1step_R2_maskV_-1.0=0.34045795, val_rnn_1_1step_CC_maskV_-1.0=0.64042252, learning_rate=0.001\n", + "Epoch 56/101 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36071965, rnn_1_1step_R2_maskV_-1.0=0.62894899, rnn_1_1step_CC_maskV_-1.0=0.79894739, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51292437, val_rnn_1_1step_R2_maskV_-1.0=0.41671878, val_rnn_1_1step_CC_maskV_-1.0=0.6904726, learning_rate=0.001\n", + "Epoch 67/101 - loss=rnn_1_1step_loss=0.30294511, rnn_1_1step_R2_maskV_-1.0=0.68802214, rnn_1_1step_CC_maskV_-1.0=0.83427501, rnn_1_1step_MSE_maskV_-1.0=0.30294508, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47871801, val_rnn_1_1step_R2_maskV_-1.0=0.45484257, val_rnn_1_1step_CC_maskV_-1.0=0.71909422, learning_rate=0.001\n", + "Epoch 78/101 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.27366236, rnn_1_1step_R2_maskV_-1.0=0.71785182, rnn_1_1step_CC_maskV_-1.0=0.85143042, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46952692, val_rnn_1_1step_R2_maskV_-1.0=0.46499839, val_rnn_1_1step_CC_maskV_-1.0=0.72811139, learning_rate=0.001\n", + "Epoch 89/101 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.25618112, rnn_1_1step_R2_maskV_-1.0=0.73563778, rnn_1_1step_CC_maskV_-1.0=0.8615303, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4683474, val_rnn_1_1step_R2_maskV_-1.0=0.46595886, val_rnn_1_1step_CC_maskV_-1.0=0.73056281, learning_rate=0.001\n", + "Epoch 100/101 - loss=rnn_1_1step_loss=0.24430883, rnn_1_1step_R2_maskV_-1.0=0.74770212, rnn_1_1step_CC_maskV_-1.0=0.86830974, rnn_1_1step_MSE_maskV_-1.0=0.24430884, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47301793, val_rnn_1_1step_R2_maskV_-1.0=0.46027035, val_rnn_1_1step_CC_maskV_-1.0=0.72926146, learning_rate=0.001\n", + "Epoch 101/101 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.2433932, rnn_1_1step_R2_maskV_-1.0=0.74863094, rnn_1_1step_CC_maskV_-1.0=0.86882669, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4734627, val_rnn_1_1step_R2_maskV_-1.0=0.45973852, val_rnn_1_1step_CC_maskV_-1.0=0.72905469, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:57:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 11.06s\n", + "\u001b[32m2025-05-30 14:57:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.46791646)\n", + "\u001b[32m2025-05-30 14:57:27\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.224, R2_maskV_-1.0=0.776, CC_maskV_-1.0=0.881\n", + "\u001b[32m2025-05-30 14:57:27\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.436, R2_maskV_-1.0=0.518, CC_maskV_-1.0=0.754\n", + "\u001b[32m2025-05-30 14:57:27\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 14:57:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:58:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 190 (stopped at 205 epochs).\n", + "\u001b[32m2025-05-30 14:58:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/206 - loss=1.0623952, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.14778319, MSE_maskV_-1.0=1.0641975, val_loss=0.9602654, val_CC_maskV_-1.0=0.21949983, val_MSE_maskV_-1.0=0.95771194, learning_rate=0.001\n", + "Epoch 22/206 - loss=0.82182896, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4232828, MSE_maskV_-1.0=0.82262027, val_loss=0.84289092, val_CC_maskV_-1.0=0.40530181, val_MSE_maskV_-1.0=0.84152728, learning_rate=0.001\n", + "Epoch 43/206 - loss=0.78742582, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46148136, MSE_maskV_-1.0=0.78757632, val_loss=0.81054443, val_CC_maskV_-1.0=0.44087762, val_MSE_maskV_-1.0=0.80931979, learning_rate=0.001\n", + "Epoch 64/206 - loss=0.76992446, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47966087, MSE_maskV_-1.0=0.76979595, val_loss=0.79693902, val_CC_maskV_-1.0=0.45476508, val_MSE_maskV_-1.0=0.79537201, learning_rate=0.001\n", + "Epoch 85/206 - loss=0.75941968, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49002245, MSE_maskV_-1.0=0.75942791, val_loss=0.78781927, val_CC_maskV_-1.0=0.46317619, val_MSE_maskV_-1.0=0.78650969, learning_rate=0.001\n", + "Epoch 106/206 - loss=0.74974018, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49911845, MSE_maskV_-1.0=0.74924868, val_loss=0.78713453, val_CC_maskV_-1.0=0.46377581, val_MSE_maskV_-1.0=0.78580046, learning_rate=0.001\n", + "Epoch 127/206 - loss=0.7425946, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50569981, MSE_maskV_-1.0=0.74444598, val_loss=0.78115702, val_CC_maskV_-1.0=0.46908495, val_MSE_maskV_-1.0=0.7799601, learning_rate=0.001\n", + "Epoch 148/206 - loss=0.73733205, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51152241, MSE_maskV_-1.0=0.73858333, val_loss=0.77310306, val_CC_maskV_-1.0=0.4765076, val_MSE_maskV_-1.0=0.77222466, learning_rate=0.001\n", + "Epoch 169/206 - loss=0.73312712, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51544654, MSE_maskV_-1.0=0.73321182, val_loss=0.77223164, val_CC_maskV_-1.0=0.47923955, val_MSE_maskV_-1.0=0.77107024, learning_rate=0.001\n", + "Epoch 190/206 - loss=0.72998548, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5175398, MSE_maskV_-1.0=0.72982198, val_loss=0.76836926, val_CC_maskV_-1.0=0.48138395, val_MSE_maskV_-1.0=0.76751268, learning_rate=0.001\n", + "Epoch 206/206 - loss=0.72655994, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5217157, MSE_maskV_-1.0=0.72620082, val_loss=0.77172172, val_CC_maskV_-1.0=0.48017719, val_MSE_maskV_-1.0=0.77070421, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:58:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 52.13s\n", + "\u001b[32m2025-05-30 14:58:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:59:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 181 (stopped at 196 epochs).\n", + "\u001b[32m2025-05-30 14:59:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/197 - loss=1.0695361, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.13822627, MSE_maskV_-1.0=1.0713689, val_loss=0.96113563, val_CC_maskV_-1.0=0.21670458, val_MSE_maskV_-1.0=0.95919853, learning_rate=0.001\n", + "Epoch 21/197 - loss=0.8293888, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41491425, MSE_maskV_-1.0=0.82914734, val_loss=0.84976763, val_CC_maskV_-1.0=0.39993882, val_MSE_maskV_-1.0=0.84811133, learning_rate=0.001\n", + "Epoch 41/197 - loss=0.79048979, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45733681, MSE_maskV_-1.0=0.79085463, val_loss=0.81470805, val_CC_maskV_-1.0=0.43722823, val_MSE_maskV_-1.0=0.81346327, learning_rate=0.001\n", + "Epoch 61/197 - loss=0.77319402, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47652823, MSE_maskV_-1.0=0.77256924, val_loss=0.79922789, val_CC_maskV_-1.0=0.45311669, val_MSE_maskV_-1.0=0.79792291, learning_rate=0.001\n", + "Epoch 81/197 - loss=0.76109827, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48887563, MSE_maskV_-1.0=0.76109737, val_loss=0.79362196, val_CC_maskV_-1.0=0.45797813, val_MSE_maskV_-1.0=0.79268348, learning_rate=0.001\n", + "Epoch 101/197 - loss=0.75196952, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49805266, MSE_maskV_-1.0=0.75172323, val_loss=0.78143728, val_CC_maskV_-1.0=0.4695093, val_MSE_maskV_-1.0=0.78070444, learning_rate=0.001\n", + "Epoch 121/197 - loss=0.74398494, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50577819, MSE_maskV_-1.0=0.74385595, val_loss=0.77640373, val_CC_maskV_-1.0=0.47529599, val_MSE_maskV_-1.0=0.77543515, learning_rate=0.001\n", + "Epoch 141/197 - loss=0.73704755, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51175064, MSE_maskV_-1.0=0.74067968, val_loss=0.77279115, val_CC_maskV_-1.0=0.47884372, val_MSE_maskV_-1.0=0.77117366, learning_rate=0.001\n", + "Epoch 161/197 - loss=0.73278809, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51616907, MSE_maskV_-1.0=0.73276621, val_loss=0.77085805, val_CC_maskV_-1.0=0.47997609, val_MSE_maskV_-1.0=0.7700237, learning_rate=0.001\n", + "Epoch 181/197 - loss=0.72945017, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51834404, MSE_maskV_-1.0=0.72942924, val_loss=0.7637943, val_CC_maskV_-1.0=0.48597407, val_MSE_maskV_-1.0=0.76308125, learning_rate=0.001\n", + "Epoch 197/197 - loss=0.72662354, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52137029, MSE_maskV_-1.0=0.72680801, val_loss=0.76570976, val_CC_maskV_-1.0=0.48518905, val_MSE_maskV_-1.0=0.76506424, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:59:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 50.08s\n", + "\u001b[32m2025-05-30 14:59:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.7637943)\n", + "\u001b[32m2025-05-30 14:59:10\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 753us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:59:10\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.725, R2_maskV_-1.0=0.277, CC_maskV_-1.0=0.525\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 755us/step\n", + "51/51 [==============================] - 0s 755us/step\n", + "84/84 [==============================] - 0s 723us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 14:59:11\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_KCy1HL64U_ErSV16\" (10/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_KCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 14:59:11\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_CzCy1HL64U_ErSV16\" (11/16)\n", + "\u001b[32m2025-05-30 14:59:11\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_CzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 14:59:11\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 14:59:11\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 14:59:11\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 14:59:11\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 14:59:11\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 14:59:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 14:59:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 178 (stopped at 193 epochs).\n", + "\u001b[32m2025-05-30 14:59:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/194 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.99876326, rnn_1step_R2_maskV_-1.0=-0.021676097, rnn_1step_CC_maskV_-1.0=0.091274753, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96417111, val_rnn_1step_R2_maskV_-1.0=-0.086838186, val_rnn_1step_CC_maskV_-1.0=0.24657002, learning_rate=0.001\n", + "Epoch 21/194 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.62184864, rnn_1step_R2_maskV_-1.0=0.35795403, rnn_1step_CC_maskV_-1.0=0.61411154, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.66410404, val_rnn_1step_R2_maskV_-1.0=0.2438879, val_rnn_1step_CC_maskV_-1.0=0.56521821, learning_rate=0.001\n", + "Epoch 41/194 - loss=rnn_1step_loss=0.4645853, rnn_1step_R2_maskV_-1.0=0.52008951, rnn_1step_CC_maskV_-1.0=0.73001099, rnn_1step_MSE_maskV_-1.0=0.46458533, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5598368, val_rnn_1step_R2_maskV_-1.0=0.35917538, val_rnn_1step_CC_maskV_-1.0=0.66083431, learning_rate=0.001\n", + "Epoch 61/194 - loss=rnn_1step_loss=0.42638811, rnn_1step_R2_maskV_-1.0=0.5592441, rnn_1step_CC_maskV_-1.0=0.75594878, rnn_1step_MSE_maskV_-1.0=0.42638808, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53394967, val_rnn_1step_R2_maskV_-1.0=0.3870917, val_rnn_1step_CC_maskV_-1.0=0.67862225, learning_rate=0.001\n", + "Epoch 81/194 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39970374, rnn_1step_R2_maskV_-1.0=0.5869379, rnn_1step_CC_maskV_-1.0=0.77364355, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52915746, val_rnn_1step_R2_maskV_-1.0=0.39240557, val_rnn_1step_CC_maskV_-1.0=0.68295002, learning_rate=0.001\n", + "Epoch 101/194 - loss=rnn_1step_loss=0.37253222, rnn_1step_R2_maskV_-1.0=0.61481524, rnn_1step_CC_maskV_-1.0=0.79101312, rnn_1step_MSE_maskV_-1.0=0.37253219, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52423197, val_rnn_1step_R2_maskV_-1.0=0.39833075, val_rnn_1step_CC_maskV_-1.0=0.69098675, learning_rate=0.001\n", + "Epoch 121/194 - loss=rnn_1step_loss=0.35550308, rnn_1step_R2_maskV_-1.0=0.63231474, rnn_1step_CC_maskV_-1.0=0.80157685, rnn_1step_MSE_maskV_-1.0=0.35550305, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51732951, val_rnn_1step_R2_maskV_-1.0=0.40570942, val_rnn_1step_CC_maskV_-1.0=0.69973332, learning_rate=0.001\n", + "Epoch 141/194 - loss=rnn_1step_loss=0.3474389, rnn_1step_R2_maskV_-1.0=0.64062232, rnn_1step_CC_maskV_-1.0=0.80654621, rnn_1step_MSE_maskV_-1.0=0.34743887, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51552886, val_rnn_1step_R2_maskV_-1.0=0.40738162, val_rnn_1step_CC_maskV_-1.0=0.70250809, learning_rate=0.001\n", + "Epoch 161/194 - loss=rnn_1step_loss=0.34164384, rnn_1step_R2_maskV_-1.0=0.64654911, rnn_1step_CC_maskV_-1.0=0.81013513, rnn_1step_MSE_maskV_-1.0=0.34164387, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51408905, val_rnn_1step_R2_maskV_-1.0=0.40879744, val_rnn_1step_CC_maskV_-1.0=0.70399159, learning_rate=0.001\n", + "Epoch 181/194 - loss=rnn_1step_loss=0.33645502, rnn_1step_R2_maskV_-1.0=0.65190345, rnn_1step_CC_maskV_-1.0=0.81337637, rnn_1step_MSE_maskV_-1.0=0.33645505, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51374489, val_rnn_1step_R2_maskV_-1.0=0.40911615, val_rnn_1step_CC_maskV_-1.0=0.70418644, learning_rate=0.001\n", + "Epoch 194/194 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33319592, rnn_1step_R2_maskV_-1.0=0.65528381, rnn_1step_CC_maskV_-1.0=0.8154003, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51414007, val_rnn_1step_R2_maskV_-1.0=0.40863311, val_rnn_1step_CC_maskV_-1.0=0.70424831, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:59:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 19.55s\n", + "\u001b[32m2025-05-30 14:59:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 14:59:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 236 (stopped at 251 epochs).\n", + "\u001b[32m2025-05-30 14:59:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/252 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.99931353, rnn_1_1step_R2_maskV_-1.0=-0.022239111, rnn_1_1step_CC_maskV_-1.0=0.028673029, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96486497, val_rnn_1_1step_R2_maskV_-1.0=-0.087593839, val_rnn_1_1step_CC_maskV_-1.0=0.20046534, learning_rate=0.001\n", + "Epoch 27/252 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.61226714, rnn_1_1step_R2_maskV_-1.0=0.36734942, rnn_1_1step_CC_maskV_-1.0=0.62325341, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64906895, val_rnn_1_1step_R2_maskV_-1.0=0.25547206, val_rnn_1_1step_CC_maskV_-1.0=0.57879382, learning_rate=0.001\n", + "Epoch 53/252 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.47762489, rnn_1_1step_R2_maskV_-1.0=0.50525224, rnn_1_1step_CC_maskV_-1.0=0.72177744, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57063025, val_rnn_1_1step_R2_maskV_-1.0=0.34397888, val_rnn_1_1step_CC_maskV_-1.0=0.64555389, learning_rate=0.001\n", + "Epoch 79/252 - loss=rnn_1_1step_loss=0.41806796, rnn_1_1step_R2_maskV_-1.0=0.56723231, rnn_1_1step_CC_maskV_-1.0=0.76181018, rnn_1_1step_MSE_maskV_-1.0=0.41806799, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55349916, val_rnn_1_1step_R2_maskV_-1.0=0.36235124, val_rnn_1_1step_CC_maskV_-1.0=0.66539764, learning_rate=0.001\n", + "Epoch 105/252 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39562836, rnn_1_1step_R2_maskV_-1.0=0.59059858, rnn_1_1step_CC_maskV_-1.0=0.77659231, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54842591, val_rnn_1_1step_R2_maskV_-1.0=0.36850482, val_rnn_1_1step_CC_maskV_-1.0=0.67043805, learning_rate=0.001\n", + "Epoch 131/252 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.37584051, rnn_1_1step_R2_maskV_-1.0=0.61133099, rnn_1_1step_CC_maskV_-1.0=0.78920782, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5361371, val_rnn_1_1step_R2_maskV_-1.0=0.38271618, val_rnn_1_1step_CC_maskV_-1.0=0.68168646, learning_rate=0.001\n", + "Epoch 157/252 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.35484374, rnn_1_1step_R2_maskV_-1.0=0.63321477, rnn_1_1step_CC_maskV_-1.0=0.8023237, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51653826, val_rnn_1_1step_R2_maskV_-1.0=0.40513474, val_rnn_1_1step_CC_maskV_-1.0=0.69827485, learning_rate=0.001\n", + "Epoch 183/252 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.34064913, rnn_1_1step_R2_maskV_-1.0=0.64781523, rnn_1_1step_CC_maskV_-1.0=0.81097865, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50287795, val_rnn_1_1step_R2_maskV_-1.0=0.4206709, val_rnn_1_1step_CC_maskV_-1.0=0.70918089, learning_rate=0.001\n", + "Epoch 209/252 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33161548, rnn_1_1step_R2_maskV_-1.0=0.65709007, rnn_1_1step_CC_maskV_-1.0=0.8164041, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49936262, val_rnn_1_1step_R2_maskV_-1.0=0.42490166, val_rnn_1_1step_CC_maskV_-1.0=0.71297264, learning_rate=0.001\n", + "Epoch 235/252 - loss=rnn_1_1step_loss=0.32409653, rnn_1_1step_R2_maskV_-1.0=0.66482949, rnn_1_1step_CC_maskV_-1.0=0.82087284, rnn_1_1step_MSE_maskV_-1.0=0.32409656, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.500117, val_rnn_1_1step_R2_maskV_-1.0=0.42425016, val_rnn_1_1step_CC_maskV_-1.0=0.71404165, learning_rate=0.001\n", + "Epoch 252/252 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32015571, rnn_1_1step_R2_maskV_-1.0=0.66895092, rnn_1_1step_CC_maskV_-1.0=0.82331091, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4994086, val_rnn_1_1step_R2_maskV_-1.0=0.42536247, val_rnn_1_1step_CC_maskV_-1.0=0.71414518, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 14:59:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 25.18s\n", + "\u001b[32m2025-05-30 14:59:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.49893656)\n", + "\u001b[32m2025-05-30 14:59:57\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.288, R2_maskV_-1.0=0.712, CC_maskV_-1.0=0.844\n", + "\u001b[32m2025-05-30 14:59:57\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.472, R2_maskV_-1.0=0.47, CC_maskV_-1.0=0.737\n", + "\u001b[32m2025-05-30 14:59:57\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 14:59:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:00:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 140 (stopped at 155 epochs).\n", + "\u001b[32m2025-05-30 15:00:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/156 - loss=2.183712, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.064280391, MSE_maskV_-1.0=2.1824248, val_loss=1.1032765, val_CC_maskV_-1.0=0.12960267, val_MSE_maskV_-1.0=1.1012346, learning_rate=0.001\n", + "Epoch 17/156 - loss=0.75336069, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4954128, MSE_maskV_-1.0=0.75315189, val_loss=0.78037608, val_CC_maskV_-1.0=0.47353595, val_MSE_maskV_-1.0=0.77853221, learning_rate=0.001\n", + "Epoch 33/156 - loss=0.68864906, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55612099, MSE_maskV_-1.0=0.68843395, val_loss=0.71942538, val_CC_maskV_-1.0=0.53303301, val_MSE_maskV_-1.0=0.71729302, learning_rate=0.001\n", + "Epoch 49/156 - loss=0.66058594, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58097792, MSE_maskV_-1.0=0.66047078, val_loss=0.69860172, val_CC_maskV_-1.0=0.55386698, val_MSE_maskV_-1.0=0.69599909, learning_rate=0.001\n", + "Epoch 65/156 - loss=0.6482628, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59029728, MSE_maskV_-1.0=0.64850765, val_loss=0.68987906, val_CC_maskV_-1.0=0.56203729, val_MSE_maskV_-1.0=0.68695456, learning_rate=0.001\n", + "Epoch 81/156 - loss=0.63876939, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5992012, MSE_maskV_-1.0=0.63837582, val_loss=0.69299346, val_CC_maskV_-1.0=0.56096894, val_MSE_maskV_-1.0=0.68981737, learning_rate=0.001\n", + "Epoch 97/156 - loss=0.63439089, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60225976, MSE_maskV_-1.0=0.63380331, val_loss=0.68531781, val_CC_maskV_-1.0=0.56644869, val_MSE_maskV_-1.0=0.68216443, learning_rate=0.001\n", + "Epoch 113/156 - loss=0.62909567, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60649145, MSE_maskV_-1.0=0.63083208, val_loss=0.68628943, val_CC_maskV_-1.0=0.56675971, val_MSE_maskV_-1.0=0.68256986, learning_rate=0.001\n", + "Epoch 129/156 - loss=0.6265021, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60828751, MSE_maskV_-1.0=0.62618989, val_loss=0.68351364, val_CC_maskV_-1.0=0.56797171, val_MSE_maskV_-1.0=0.68046707, learning_rate=0.001\n", + "Epoch 145/156 - loss=0.62431043, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60975695, MSE_maskV_-1.0=0.62452495, val_loss=0.68497658, val_CC_maskV_-1.0=0.56715721, val_MSE_maskV_-1.0=0.68181515, learning_rate=0.001\n", + "Epoch 156/156 - loss=0.62222099, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61169678, MSE_maskV_-1.0=0.62256032, val_loss=0.67920959, val_CC_maskV_-1.0=0.57126623, val_MSE_maskV_-1.0=0.67601043, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:00:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 39.85s\n", + "\u001b[32m2025-05-30 15:00:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:01:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 77 (stopped at 92 epochs).\n", + "\u001b[32m2025-05-30 15:01:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/93 - loss=1.8976277, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.067265324, MSE_maskV_-1.0=1.8971928, val_loss=1.0613574, val_CC_maskV_-1.0=0.15531759, val_MSE_maskV_-1.0=1.059871, learning_rate=0.001\n", + "Epoch 11/93 - loss=0.77161193, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47753033, MSE_maskV_-1.0=0.77186561, val_loss=0.79565722, val_CC_maskV_-1.0=0.45728278, val_MSE_maskV_-1.0=0.79409266, learning_rate=0.001\n", + "Epoch 21/93 - loss=0.71319669, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53492641, MSE_maskV_-1.0=0.71297836, val_loss=0.74060136, val_CC_maskV_-1.0=0.5134995, val_MSE_maskV_-1.0=0.73821104, learning_rate=0.001\n", + "Epoch 31/93 - loss=0.67962921, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56449854, MSE_maskV_-1.0=0.67986196, val_loss=0.71211958, val_CC_maskV_-1.0=0.54137063, val_MSE_maskV_-1.0=0.70915622, learning_rate=0.001\n", + "Epoch 41/93 - loss=0.66352385, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5780111, MSE_maskV_-1.0=0.66359967, val_loss=0.70482075, val_CC_maskV_-1.0=0.54909581, val_MSE_maskV_-1.0=0.70187122, learning_rate=0.001\n", + "Epoch 51/93 - loss=0.65194649, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58765203, MSE_maskV_-1.0=0.65161264, val_loss=0.69408417, val_CC_maskV_-1.0=0.55821848, val_MSE_maskV_-1.0=0.69098729, learning_rate=0.001\n", + "Epoch 61/93 - loss=0.6456964, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59272391, MSE_maskV_-1.0=0.64519602, val_loss=0.69207674, val_CC_maskV_-1.0=0.5609287, val_MSE_maskV_-1.0=0.68848294, learning_rate=0.001\n", + "Epoch 71/93 - loss=0.63984907, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59806782, MSE_maskV_-1.0=0.63989425, val_loss=0.69160235, val_CC_maskV_-1.0=0.56175071, val_MSE_maskV_-1.0=0.68840164, learning_rate=0.001\n", + "Epoch 81/93 - loss=0.63524967, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60219222, MSE_maskV_-1.0=0.63489926, val_loss=0.68965083, val_CC_maskV_-1.0=0.56464678, val_MSE_maskV_-1.0=0.68626148, learning_rate=0.001\n", + "Epoch 91/93 - loss=0.63199723, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60470825, MSE_maskV_-1.0=0.63226932, val_loss=0.68657237, val_CC_maskV_-1.0=0.56734318, val_MSE_maskV_-1.0=0.68295676, learning_rate=0.001\n", + "Epoch 93/93 - loss=0.63182366, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6041851, MSE_maskV_-1.0=0.63115811, val_loss=0.68798494, val_CC_maskV_-1.0=0.56501269, val_MSE_maskV_-1.0=0.68426138, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:01:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 24.56s\n", + "\u001b[32m2025-05-30 15:01:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.67791808)\n", + "\u001b[32m2025-05-30 15:01:02\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 786us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:01:02\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.618, R2_maskV_-1.0=0.383, CC_maskV_-1.0=0.618\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 792us/step\n", + "51/51 [==============================] - 0s 817us/step\n", + "84/84 [==============================] - 0s 732us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:01:03\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_CzCy1HL64U_ErSV16\" (11/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_CzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:01:03\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_uAKCz1HL64U_ErSV16\" (12/16)\n", + "\u001b[32m2025-05-30 15:01:03\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:01:03\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:01:03\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:01:03\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:01:03\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:01:03\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:01:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:01:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 85 (stopped at 100 epochs).\n", + "\u001b[32m2025-05-30 15:01:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/101 - loss=rnn_1step_loss=0.99941349, rnn_1step_R2_maskV_-1.0=-0.02233462, rnn_1step_CC_maskV_-1.0=0.036192063, rnn_1step_MSE_maskV_-1.0=0.99941343, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.9653492, val_rnn_1step_R2_maskV_-1.0=-0.088121325, val_rnn_1step_CC_maskV_-1.0=0.31435028, learning_rate=0.001\n", + "Epoch 12/101 - loss=rnn_1step_loss=0.81770545, rnn_1step_R2_maskV_-1.0=0.16197164, rnn_1step_CC_maskV_-1.0=0.45217821, rnn_1step_MSE_maskV_-1.0=0.81770539, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.75508863, val_rnn_1step_R2_maskV_-1.0=0.1435796, val_rnn_1step_CC_maskV_-1.0=0.49826306, learning_rate=0.001\n", + "Epoch 23/101 - loss=rnn_1step_loss=0.57868737, rnn_1step_R2_maskV_-1.0=0.39921707, rnn_1step_CC_maskV_-1.0=0.64956445, rnn_1step_MSE_maskV_-1.0=0.57868731, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63616014, val_rnn_1step_R2_maskV_-1.0=0.27106619, val_rnn_1step_CC_maskV_-1.0=0.58822513, learning_rate=0.001\n", + "Epoch 34/101 - loss=rnn_1step_loss=0.50185108, rnn_1step_R2_maskV_-1.0=0.4765833, rnn_1step_CC_maskV_-1.0=0.70563757, rnn_1step_MSE_maskV_-1.0=0.50185102, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60446453, val_rnn_1step_R2_maskV_-1.0=0.30723518, val_rnn_1step_CC_maskV_-1.0=0.61698389, learning_rate=0.001\n", + "Epoch 45/101 - loss=rnn_1step_loss=0.45422307, rnn_1step_R2_maskV_-1.0=0.52633041, rnn_1step_CC_maskV_-1.0=0.73751837, rnn_1step_MSE_maskV_-1.0=0.4542231, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59248167, val_rnn_1step_R2_maskV_-1.0=0.32073838, val_rnn_1step_CC_maskV_-1.0=0.62523496, learning_rate=0.001\n", + "Epoch 56/101 - loss=rnn_1step_loss=0.4129549, rnn_1step_R2_maskV_-1.0=0.5692299, rnn_1step_CC_maskV_-1.0=0.76454473, rnn_1step_MSE_maskV_-1.0=0.41295487, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55658287, val_rnn_1step_R2_maskV_-1.0=0.36153823, val_rnn_1step_CC_maskV_-1.0=0.65004808, learning_rate=0.001\n", + "Epoch 67/101 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.36734068, rnn_1step_R2_maskV_-1.0=0.61710328, rnn_1step_CC_maskV_-1.0=0.794025, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53037566, val_rnn_1step_R2_maskV_-1.0=0.391307, val_rnn_1step_CC_maskV_-1.0=0.67468935, learning_rate=0.001\n", + "Epoch 78/101 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34004888, rnn_1step_R2_maskV_-1.0=0.64583981, rnn_1step_CC_maskV_-1.0=0.81099129, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51846081, val_rnn_1step_R2_maskV_-1.0=0.40595832, val_rnn_1step_CC_maskV_-1.0=0.68503296, learning_rate=0.001\n", + "Epoch 89/101 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32308128, rnn_1step_R2_maskV_-1.0=0.66360426, rnn_1step_CC_maskV_-1.0=0.82197821, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51302648, val_rnn_1step_R2_maskV_-1.0=0.41303414, val_rnn_1step_CC_maskV_-1.0=0.68563104, learning_rate=0.001\n", + "Epoch 100/101 - loss=rnn_1step_loss=0.30687961, rnn_1step_R2_maskV_-1.0=0.68055475, rnn_1step_CC_maskV_-1.0=0.83295006, rnn_1step_MSE_maskV_-1.0=0.30687964, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53568178, val_rnn_1step_R2_maskV_-1.0=0.38642216, val_rnn_1step_CC_maskV_-1.0=0.6740253, learning_rate=0.001\n", + "Epoch 101/101 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30583826, rnn_1step_R2_maskV_-1.0=0.68127555, rnn_1step_CC_maskV_-1.0=0.83264458, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51568717, val_rnn_1step_R2_maskV_-1.0=0.41068387, val_rnn_1step_CC_maskV_-1.0=0.68650055, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:01:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.80s\n", + "\u001b[32m2025-05-30 15:01:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:01:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 113 (stopped at 128 epochs).\n", + "\u001b[32m2025-05-30 15:01:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.99948335, rnn_1_1step_R2_maskV_-1.0=-0.022404063, rnn_1_1step_CC_maskV_-1.0=0.0042474712, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96558404, val_rnn_1_1step_R2_maskV_-1.0=-0.088399306, val_rnn_1_1step_CC_maskV_-1.0=0.27924064, learning_rate=0.001\n", + "Epoch 14/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.84688807, rnn_1_1step_R2_maskV_-1.0=0.13170823, rnn_1_1step_CC_maskV_-1.0=0.39183694, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.80992478, val_rnn_1_1step_R2_maskV_-1.0=0.078438014, val_rnn_1_1step_CC_maskV_-1.0=0.40920344, learning_rate=0.001\n", + "Epoch 27/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.67459559, rnn_1_1step_R2_maskV_-1.0=0.30259651, rnn_1_1step_CC_maskV_-1.0=0.57148635, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.7158106, val_rnn_1_1step_R2_maskV_-1.0=0.18755509, val_rnn_1_1step_CC_maskV_-1.0=0.51217639, learning_rate=0.001\n", + "Epoch 40/129 - loss=rnn_1_1step_loss=0.51988786, rnn_1_1step_R2_maskV_-1.0=0.45955122, rnn_1_1step_CC_maskV_-1.0=0.69353622, rnn_1_1step_MSE_maskV_-1.0=0.51988792, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62236667, val_rnn_1_1step_R2_maskV_-1.0=0.28755081, val_rnn_1_1step_CC_maskV_-1.0=0.60254461, learning_rate=0.001\n", + "Epoch 53/129 - loss=rnn_1_1step_loss=0.39871454, rnn_1_1step_R2_maskV_-1.0=0.58606827, rnn_1_1step_CC_maskV_-1.0=0.7755596, rnn_1_1step_MSE_maskV_-1.0=0.39871457, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60477537, val_rnn_1_1step_R2_maskV_-1.0=0.30589604, val_rnn_1_1step_CC_maskV_-1.0=0.63453346, learning_rate=0.001\n", + "Epoch 66/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33649215, rnn_1_1step_R2_maskV_-1.0=0.65052378, rnn_1_1step_CC_maskV_-1.0=0.8135435, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54700881, val_rnn_1_1step_R2_maskV_-1.0=0.37582254, val_rnn_1_1step_CC_maskV_-1.0=0.66717505, learning_rate=0.001\n", + "Epoch 79/129 - loss=rnn_1_1step_loss=0.29955229, rnn_1_1step_R2_maskV_-1.0=0.68929362, rnn_1_1step_CC_maskV_-1.0=0.83585519, rnn_1_1step_MSE_maskV_-1.0=0.29955232, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54267973, val_rnn_1_1step_R2_maskV_-1.0=0.38013789, val_rnn_1_1step_CC_maskV_-1.0=0.68010229, learning_rate=0.001\n", + "Epoch 92/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.27306405, rnn_1_1step_R2_maskV_-1.0=0.71717131, rnn_1_1step_CC_maskV_-1.0=0.85189986, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50857311, val_rnn_1_1step_R2_maskV_-1.0=0.42085618, val_rnn_1_1step_CC_maskV_-1.0=0.69491112, learning_rate=0.001\n", + "Epoch 105/129 - loss=rnn_1_1step_loss=0.25287172, rnn_1_1step_R2_maskV_-1.0=0.7376653, rnn_1_1step_CC_maskV_-1.0=0.86332303, rnn_1_1step_MSE_maskV_-1.0=0.25287175, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52867341, val_rnn_1_1step_R2_maskV_-1.0=0.39664811, val_rnn_1_1step_CC_maskV_-1.0=0.69155359, learning_rate=0.001\n", + "Epoch 118/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.25352097, rnn_1_1step_R2_maskV_-1.0=0.73689359, rnn_1_1step_CC_maskV_-1.0=0.86353362, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55866218, val_rnn_1_1step_R2_maskV_-1.0=0.36016026, val_rnn_1_1step_CC_maskV_-1.0=0.68077934, learning_rate=0.001\n", + "Epoch 129/129 - loss=rnn_1_1step_loss=0.2274199, rnn_1_1step_R2_maskV_-1.0=0.76459479, rnn_1_1step_CC_maskV_-1.0=0.87826252, rnn_1_1step_MSE_maskV_-1.0=0.22741988, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53538829, val_rnn_1_1step_R2_maskV_-1.0=0.38980949, val_rnn_1_1step_CC_maskV_-1.0=0.69074613, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:01:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.65s\n", + "\u001b[32m2025-05-30 15:01:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.48509443)\n", + "\u001b[32m2025-05-30 15:01:33\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.239, R2_maskV_-1.0=0.761, CC_maskV_-1.0=0.877\n", + "\u001b[32m2025-05-30 15:01:33\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.447, R2_maskV_-1.0=0.505, CC_maskV_-1.0=0.737\n", + "\u001b[32m2025-05-30 15:01:33\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:01:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:02:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 248 (stopped at 263 epochs).\n", + "\u001b[32m2025-05-30 15:02:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/264 - loss=2.2758868, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=-0.0047358437, MSE_maskV_-1.0=2.2744284, val_loss=1.1520772, val_CC_maskV_-1.0=0.029906126, val_MSE_maskV_-1.0=1.147706, learning_rate=0.001\n", + "Epoch 28/264 - loss=0.88984972, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.33466366, MSE_maskV_-1.0=0.89079314, val_loss=0.89691287, val_CC_maskV_-1.0=0.33842999, val_MSE_maskV_-1.0=0.89395279, learning_rate=0.001\n", + "Epoch 55/264 - loss=0.86825937, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36559498, MSE_maskV_-1.0=0.86759943, val_loss=0.87554759, val_CC_maskV_-1.0=0.36875904, val_MSE_maskV_-1.0=0.87258422, learning_rate=0.001\n", + "Epoch 82/264 - loss=0.85567391, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38251081, MSE_maskV_-1.0=0.85519767, val_loss=0.86551589, val_CC_maskV_-1.0=0.38195372, val_MSE_maskV_-1.0=0.86311305, learning_rate=0.001\n", + "Epoch 109/264 - loss=0.84586251, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39586529, MSE_maskV_-1.0=0.84539819, val_loss=0.85551316, val_CC_maskV_-1.0=0.39593348, val_MSE_maskV_-1.0=0.85289389, learning_rate=0.001\n", + "Epoch 136/264 - loss=0.83794427, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40612686, MSE_maskV_-1.0=0.8384608, val_loss=0.85067815, val_CC_maskV_-1.0=0.40039167, val_MSE_maskV_-1.0=0.84842569, learning_rate=0.001\n", + "Epoch 163/264 - loss=0.83226639, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41309014, MSE_maskV_-1.0=0.83169341, val_loss=0.84564, val_CC_maskV_-1.0=0.4074142, val_MSE_maskV_-1.0=0.84360766, learning_rate=0.001\n", + "Epoch 190/264 - loss=0.82849741, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41652331, MSE_maskV_-1.0=0.82827628, val_loss=0.84023112, val_CC_maskV_-1.0=0.41176829, val_MSE_maskV_-1.0=0.83858645, learning_rate=0.001\n", + "Epoch 217/264 - loss=0.82445478, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42206311, MSE_maskV_-1.0=0.82397872, val_loss=0.83968705, val_CC_maskV_-1.0=0.41473433, val_MSE_maskV_-1.0=0.83718318, learning_rate=0.001\n", + "Epoch 244/264 - loss=0.82125145, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42504495, MSE_maskV_-1.0=0.8210665, val_loss=0.83536726, val_CC_maskV_-1.0=0.41791832, val_MSE_maskV_-1.0=0.8341828, learning_rate=0.001\n", + "Epoch 264/264 - loss=0.81948984, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4271788, MSE_maskV_-1.0=0.82109797, val_loss=0.83323073, val_CC_maskV_-1.0=0.42148849, val_MSE_maskV_-1.0=0.83124608, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:02:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 61.95s\n", + "\u001b[32m2025-05-30 15:02:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:03:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 187 (stopped at 202 epochs).\n", + "\u001b[32m2025-05-30 15:03:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/203 - loss=2.2924557, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.013891876, MSE_maskV_-1.0=2.2909777, val_loss=1.170447, val_CC_maskV_-1.0=0.032921836, val_MSE_maskV_-1.0=1.1682245, learning_rate=0.001\n", + "Epoch 22/203 - loss=0.8981818, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.32184893, MSE_maskV_-1.0=0.89904892, val_loss=0.90435749, val_CC_maskV_-1.0=0.32766196, val_MSE_maskV_-1.0=0.90112108, learning_rate=0.001\n", + "Epoch 43/203 - loss=0.87650234, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35351351, MSE_maskV_-1.0=0.87690008, val_loss=0.88613552, val_CC_maskV_-1.0=0.35447234, val_MSE_maskV_-1.0=0.88350439, learning_rate=0.001\n", + "Epoch 64/203 - loss=0.86372209, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37127972, MSE_maskV_-1.0=0.8637526, val_loss=0.8743003, val_CC_maskV_-1.0=0.36929619, val_MSE_maskV_-1.0=0.87137628, learning_rate=0.001\n", + "Epoch 85/203 - loss=0.85460162, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38454786, MSE_maskV_-1.0=0.85480481, val_loss=0.86534894, val_CC_maskV_-1.0=0.38183266, val_MSE_maskV_-1.0=0.86300337, learning_rate=0.001\n", + "Epoch 106/203 - loss=0.84688258, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39417255, MSE_maskV_-1.0=0.84610212, val_loss=0.85768932, val_CC_maskV_-1.0=0.391666, val_MSE_maskV_-1.0=0.85501212, learning_rate=0.001\n", + "Epoch 127/203 - loss=0.84077322, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40174833, MSE_maskV_-1.0=0.84258121, val_loss=0.85165018, val_CC_maskV_-1.0=0.40008238, val_MSE_maskV_-1.0=0.84884417, learning_rate=0.001\n", + "Epoch 148/203 - loss=0.83577108, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40847597, MSE_maskV_-1.0=0.83719921, val_loss=0.84700233, val_CC_maskV_-1.0=0.40526915, val_MSE_maskV_-1.0=0.84432608, learning_rate=0.001\n", + "Epoch 169/203 - loss=0.8318544, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4129096, MSE_maskV_-1.0=0.83215439, val_loss=0.84282607, val_CC_maskV_-1.0=0.41082659, val_MSE_maskV_-1.0=0.84042746, learning_rate=0.001\n", + "Epoch 190/203 - loss=0.82877254, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4162046, MSE_maskV_-1.0=0.82854027, val_loss=0.84035242, val_CC_maskV_-1.0=0.41136238, val_MSE_maskV_-1.0=0.8388325, learning_rate=0.001\n", + "Epoch 203/203 - loss=0.82657534, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41978839, MSE_maskV_-1.0=0.82617295, val_loss=0.83964455, val_CC_maskV_-1.0=0.41523564, val_MSE_maskV_-1.0=0.8368879, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:03:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 48.62s\n", + "\u001b[32m2025-05-30 15:03:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.83221704)\n", + "\u001b[32m2025-05-30 15:03:24\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 698us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:03:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.819, R2_maskV_-1.0=0.181, CC_maskV_-1.0=0.428\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 678us/step\n", + "51/51 [==============================] - 0s 758us/step\n", + "84/84 [==============================] - 0s 673us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:03:25\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_uAKCz1HL64U_ErSV16\" (12/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_uAKCz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:03:25\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_uAKCy1HL64U_ErSV16\" (13/16)\n", + "\u001b[32m2025-05-30 15:03:25\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:03:25\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:03:25\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:03:25\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:03:25\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:03:25\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:03:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:03:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 108 (stopped at 123 epochs).\n", + "\u001b[32m2025-05-30 15:03:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/124 - loss=rnn_1step_loss=0.99891335, rnn_1step_R2_maskV_-1.0=-0.021828622, rnn_1step_CC_maskV_-1.0=0.083467618, rnn_1step_MSE_maskV_-1.0=0.99891341, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96430606, val_rnn_1step_R2_maskV_-1.0=-0.086997211, val_rnn_1step_CC_maskV_-1.0=0.26451483, learning_rate=0.001\n", + "Epoch 14/124 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.77158922, rnn_1step_R2_maskV_-1.0=0.20763434, rnn_1step_CC_maskV_-1.0=0.48463953, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.7586934, val_rnn_1step_R2_maskV_-1.0=0.13656425, val_rnn_1step_CC_maskV_-1.0=0.46361038, learning_rate=0.001\n", + "Epoch 27/124 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.57342017, rnn_1step_R2_maskV_-1.0=0.40490988, rnn_1step_CC_maskV_-1.0=0.65216112, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.65670836, val_rnn_1step_R2_maskV_-1.0=0.25076726, val_rnn_1step_CC_maskV_-1.0=0.56622618, learning_rate=0.001\n", + "Epoch 40/124 - loss=rnn_1step_loss=0.48368171, rnn_1step_R2_maskV_-1.0=0.49783909, rnn_1step_CC_maskV_-1.0=0.71709692, rnn_1step_MSE_maskV_-1.0=0.48368174, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64270431, val_rnn_1step_R2_maskV_-1.0=0.26771468, val_rnn_1step_CC_maskV_-1.0=0.58897603, learning_rate=0.001\n", + "Epoch 53/124 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40636918, rnn_1step_R2_maskV_-1.0=0.57830858, rnn_1step_CC_maskV_-1.0=0.76912159, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59694797, val_rnn_1step_R2_maskV_-1.0=0.31936109, val_rnn_1step_CC_maskV_-1.0=0.62728274, learning_rate=0.001\n", + "Epoch 66/124 - loss=rnn_1step_loss=0.34403512, rnn_1step_R2_maskV_-1.0=0.64433849, rnn_1step_CC_maskV_-1.0=0.80844247, rnn_1step_MSE_maskV_-1.0=0.34403506, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56533605, val_rnn_1step_R2_maskV_-1.0=0.35251728, val_rnn_1step_CC_maskV_-1.0=0.65972137, learning_rate=0.001\n", + "Epoch 79/124 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30874696, rnn_1step_R2_maskV_-1.0=0.68116403, rnn_1step_CC_maskV_-1.0=0.83044237, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53983957, val_rnn_1step_R2_maskV_-1.0=0.38084692, val_rnn_1step_CC_maskV_-1.0=0.67933083, learning_rate=0.001\n", + "Epoch 92/124 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27753782, rnn_1step_R2_maskV_-1.0=0.71348089, rnn_1step_CC_maskV_-1.0=0.84917343, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51058841, val_rnn_1step_R2_maskV_-1.0=0.415353, val_rnn_1step_CC_maskV_-1.0=0.69636887, learning_rate=0.001\n", + "Epoch 105/124 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.24836244, rnn_1step_R2_maskV_-1.0=0.74357802, rnn_1step_CC_maskV_-1.0=0.86656797, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49692726, val_rnn_1step_R2_maskV_-1.0=0.43207526, val_rnn_1step_CC_maskV_-1.0=0.7042709, learning_rate=0.001\n", + "Epoch 118/124 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.2279731, rnn_1step_R2_maskV_-1.0=0.7645272, rnn_1step_CC_maskV_-1.0=0.87824553, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50116885, val_rnn_1step_R2_maskV_-1.0=0.42776799, val_rnn_1step_CC_maskV_-1.0=0.70573169, learning_rate=0.001\n", + "Epoch 124/124 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.2194256, rnn_1step_R2_maskV_-1.0=0.77331132, rnn_1step_CC_maskV_-1.0=0.88261557, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50886291, val_rnn_1step_R2_maskV_-1.0=0.41931176, val_rnn_1step_CC_maskV_-1.0=0.70315349, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:03:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 18.04s\n", + "\u001b[32m2025-05-30 15:03:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:03:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 31 (stopped at 46 epochs).\n", + "\u001b[32m2025-05-30 15:03:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/47 - loss=rnn_1_1step_loss=0.99943238, rnn_1_1step_R2_maskV_-1.0=-0.022372294, rnn_1_1step_CC_maskV_-1.0=0.0072355168, rnn_1_1step_MSE_maskV_-1.0=0.99943244, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96457982, val_rnn_1_1step_R2_maskV_-1.0=-0.087278217, val_rnn_1_1step_CC_maskV_-1.0=0.21644258, learning_rate=0.001\n", + "Epoch 6/47 - loss=rnn_1_1step_loss=0.97822046, rnn_1_1step_R2_maskV_-1.0=-0.00076470897, rnn_1_1step_CC_maskV_-1.0=0.38790193, rnn_1_1step_MSE_maskV_-1.0=0.97822052, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.94058657, val_rnn_1_1step_R2_maskV_-1.0=-0.060268149, val_rnn_1_1step_CC_maskV_-1.0=0.38048849, learning_rate=0.001\n", + "Epoch 11/47 - loss=rnn_1_1step_loss=0.85964328, rnn_1_1step_R2_maskV_-1.0=0.11855975, rnn_1_1step_CC_maskV_-1.0=0.43372259, rnn_1_1step_MSE_maskV_-1.0=0.85964334, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.80988979, val_rnn_1_1step_R2_maskV_-1.0=0.085316673, val_rnn_1_1step_CC_maskV_-1.0=0.43813354, learning_rate=0.001\n", + "Epoch 16/47 - loss=rnn_1_1step_loss=0.70936853, rnn_1_1step_R2_maskV_-1.0=0.27011293, rnn_1_1step_CC_maskV_-1.0=0.54527992, rnn_1_1step_MSE_maskV_-1.0=0.70936859, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.72542077, val_rnn_1_1step_R2_maskV_-1.0=0.17715089, val_rnn_1_1step_CC_maskV_-1.0=0.51745546, learning_rate=0.001\n", + "Epoch 21/47 - loss=rnn_1_1step_loss=0.58381063, rnn_1_1step_R2_maskV_-1.0=0.39448074, rnn_1_1step_CC_maskV_-1.0=0.64819521, rnn_1_1step_MSE_maskV_-1.0=0.58381069, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65201014, val_rnn_1_1step_R2_maskV_-1.0=0.25610882, val_rnn_1_1step_CC_maskV_-1.0=0.58274364, learning_rate=0.001\n", + "Epoch 26/47 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.49446651, rnn_1_1step_R2_maskV_-1.0=0.48590499, rnn_1_1step_CC_maskV_-1.0=0.7125079, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56764227, val_rnn_1_1step_R2_maskV_-1.0=0.35126024, val_rnn_1_1step_CC_maskV_-1.0=0.64343888, learning_rate=0.001\n", + "Epoch 31/47 - loss=rnn_1_1step_loss=0.43223897, rnn_1_1step_R2_maskV_-1.0=0.54965293, rnn_1_1step_CC_maskV_-1.0=0.75320065, rnn_1_1step_MSE_maskV_-1.0=0.432239, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53125429, val_rnn_1_1step_R2_maskV_-1.0=0.39333761, val_rnn_1_1step_CC_maskV_-1.0=0.67198753, learning_rate=0.001\n", + "Epoch 36/47 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39446631, rnn_1_1step_R2_maskV_-1.0=0.58865738, rnn_1_1step_CC_maskV_-1.0=0.7775839, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53687721, val_rnn_1_1step_R2_maskV_-1.0=0.38637674, val_rnn_1_1step_CC_maskV_-1.0=0.67174989, learning_rate=0.001\n", + "Epoch 41/47 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36855939, rnn_1_1step_R2_maskV_-1.0=0.61591619, rnn_1_1step_CC_maskV_-1.0=0.79399461, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53399497, val_rnn_1_1step_R2_maskV_-1.0=0.38925022, val_rnn_1_1step_CC_maskV_-1.0=0.67487717, learning_rate=0.001\n", + "Epoch 46/47 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.34893474, rnn_1_1step_R2_maskV_-1.0=0.63678098, rnn_1_1step_CC_maskV_-1.0=0.80630749, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5352456, val_rnn_1_1step_R2_maskV_-1.0=0.3874312, val_rnn_1_1step_CC_maskV_-1.0=0.67625844, learning_rate=0.001\n", + "Epoch 47/47 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.34601879, rnn_1_1step_R2_maskV_-1.0=0.63989484, rnn_1_1step_CC_maskV_-1.0=0.80783623, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53243297, val_rnn_1_1step_R2_maskV_-1.0=0.39072603, val_rnn_1_1step_CC_maskV_-1.0=0.6778391, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:03:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 7.25s\n", + "\u001b[32m2025-05-30 15:03:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.47953191)\n", + "\u001b[32m2025-05-30 15:03:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.232, R2_maskV_-1.0=0.768, CC_maskV_-1.0=0.877\n", + "\u001b[32m2025-05-30 15:03:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.455, R2_maskV_-1.0=0.493, CC_maskV_-1.0=0.736\n", + "\u001b[32m2025-05-30 15:03:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:03:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:04:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 137 (stopped at 152 epochs).\n", + "\u001b[32m2025-05-30 15:04:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/153 - loss=1.0198022, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.158683, MSE_maskV_-1.0=1.0216419, val_loss=0.94784552, val_CC_maskV_-1.0=0.24009755, val_MSE_maskV_-1.0=0.94527024, learning_rate=0.001\n", + "Epoch 17/153 - loss=0.81467384, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43081176, MSE_maskV_-1.0=0.81425607, val_loss=0.83982813, val_CC_maskV_-1.0=0.40604872, val_MSE_maskV_-1.0=0.8365773, learning_rate=0.001\n", + "Epoch 33/153 - loss=0.77720851, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47091484, MSE_maskV_-1.0=0.77700269, val_loss=0.8063373, val_CC_maskV_-1.0=0.4386076, val_MSE_maskV_-1.0=0.80412698, learning_rate=0.001\n", + "Epoch 49/153 - loss=0.75701982, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4914602, MSE_maskV_-1.0=0.75687754, val_loss=0.79504192, val_CC_maskV_-1.0=0.44988027, val_MSE_maskV_-1.0=0.79287809, learning_rate=0.001\n", + "Epoch 65/153 - loss=0.74504542, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5023849, MSE_maskV_-1.0=0.74555397, val_loss=0.78857636, val_CC_maskV_-1.0=0.45703936, val_MSE_maskV_-1.0=0.78619945, learning_rate=0.001\n", + "Epoch 81/153 - loss=0.73688394, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51129526, MSE_maskV_-1.0=0.7369101, val_loss=0.78278315, val_CC_maskV_-1.0=0.4631682, val_MSE_maskV_-1.0=0.78047442, learning_rate=0.001\n", + "Epoch 97/153 - loss=0.73158824, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51566458, MSE_maskV_-1.0=0.73083115, val_loss=0.77994376, val_CC_maskV_-1.0=0.46721518, val_MSE_maskV_-1.0=0.77745986, learning_rate=0.001\n", + "Epoch 113/153 - loss=0.72693157, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52010798, MSE_maskV_-1.0=0.72949755, val_loss=0.77958727, val_CC_maskV_-1.0=0.46877122, val_MSE_maskV_-1.0=0.77676576, learning_rate=0.001\n", + "Epoch 129/153 - loss=0.72305936, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52401024, MSE_maskV_-1.0=0.72290283, val_loss=0.77674299, val_CC_maskV_-1.0=0.4708679, val_MSE_maskV_-1.0=0.77453738, learning_rate=0.001\n", + "Epoch 145/153 - loss=0.72022194, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52577519, MSE_maskV_-1.0=0.72054809, val_loss=0.77324957, val_CC_maskV_-1.0=0.47426197, val_MSE_maskV_-1.0=0.77069217, learning_rate=0.001\n", + "Epoch 153/153 - loss=0.71892518, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52789772, MSE_maskV_-1.0=0.71846211, val_loss=0.77425885, val_CC_maskV_-1.0=0.4745093, val_MSE_maskV_-1.0=0.77154785, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:04:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 39.75s\n", + "\u001b[32m2025-05-30 15:04:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:05:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 190 (stopped at 205 epochs).\n", + "\u001b[32m2025-05-30 15:05:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/206 - loss=1.0289489, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.15968676, MSE_maskV_-1.0=1.0308695, val_loss=0.95180398, val_CC_maskV_-1.0=0.23855236, val_MSE_maskV_-1.0=0.94745129, learning_rate=0.001\n", + "Epoch 22/206 - loss=0.79782796, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44994256, MSE_maskV_-1.0=0.79837376, val_loss=0.82647133, val_CC_maskV_-1.0=0.42024779, val_MSE_maskV_-1.0=0.82351094, learning_rate=0.001\n", + "Epoch 43/206 - loss=0.76268822, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48628196, MSE_maskV_-1.0=0.76298225, val_loss=0.80105126, val_CC_maskV_-1.0=0.44620144, val_MSE_maskV_-1.0=0.79821104, learning_rate=0.001\n", + "Epoch 64/206 - loss=0.7456159, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50309134, MSE_maskV_-1.0=0.74556059, val_loss=0.78783303, val_CC_maskV_-1.0=0.4587408, val_MSE_maskV_-1.0=0.78518945, learning_rate=0.001\n", + "Epoch 85/206 - loss=0.73390698, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.512842, MSE_maskV_-1.0=0.73386294, val_loss=0.78259933, val_CC_maskV_-1.0=0.46423808, val_MSE_maskV_-1.0=0.78051198, learning_rate=0.001\n", + "Epoch 106/206 - loss=0.72643977, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51956677, MSE_maskV_-1.0=0.72598624, val_loss=0.78078687, val_CC_maskV_-1.0=0.46677631, val_MSE_maskV_-1.0=0.7783094, learning_rate=0.001\n", + "Epoch 127/206 - loss=0.72001088, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52583557, MSE_maskV_-1.0=0.72140592, val_loss=0.77739531, val_CC_maskV_-1.0=0.47017813, val_MSE_maskV_-1.0=0.77458054, learning_rate=0.001\n", + "Epoch 148/206 - loss=0.71517873, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53143156, MSE_maskV_-1.0=0.71650797, val_loss=0.77144414, val_CC_maskV_-1.0=0.47674683, val_MSE_maskV_-1.0=0.76887721, learning_rate=0.001\n", + "Epoch 169/206 - loss=0.71197689, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53378552, MSE_maskV_-1.0=0.7121039, val_loss=0.7723043, val_CC_maskV_-1.0=0.47661325, val_MSE_maskV_-1.0=0.76974201, learning_rate=0.001\n", + "Epoch 190/206 - loss=0.70930165, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53586, MSE_maskV_-1.0=0.70906508, val_loss=0.76722527, val_CC_maskV_-1.0=0.48081395, val_MSE_maskV_-1.0=0.76475698, learning_rate=0.001\n", + "Epoch 206/206 - loss=0.70693988, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53832644, MSE_maskV_-1.0=0.70682847, val_loss=0.77118808, val_CC_maskV_-1.0=0.47913194, val_MSE_maskV_-1.0=0.7681483, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:05:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 52.14s\n", + "\u001b[32m2025-05-30 15:05:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.76722527)\n", + "\u001b[32m2025-05-30 15:05:24\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 761us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:05:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.705, R2_maskV_-1.0=0.296, CC_maskV_-1.0=0.543\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 768us/step\n", + "51/51 [==============================] - 0s 785us/step\n", + "84/84 [==============================] - 0s 740us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:05:25\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_uAKCy1HL64U_ErSV16\" (13/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_uAKCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:05:25\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_ACzCy1HL64U_ErSV16\" (14/16)\n", + "\u001b[32m2025-05-30 15:05:25\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:05:25\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:05:25\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:05:25\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:05:25\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:05:25\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:05:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:05:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 109 (stopped at 124 epochs).\n", + "\u001b[32m2025-05-30 15:05:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/125 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.99896318, rnn_1step_R2_maskV_-1.0=-0.021887168, rnn_1step_CC_maskV_-1.0=0.07249175, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96461946, val_rnn_1step_R2_maskV_-1.0=-0.087336019, val_rnn_1step_CC_maskV_-1.0=0.22884098, learning_rate=0.001\n", + "Epoch 14/125 - loss=rnn_1step_loss=0.76725549, rnn_1step_R2_maskV_-1.0=0.20944859, rnn_1step_CC_maskV_-1.0=0.48323697, rnn_1step_MSE_maskV_-1.0=0.76725554, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.77669144, val_rnn_1step_R2_maskV_-1.0=0.11355539, val_rnn_1step_CC_maskV_-1.0=0.45880371, learning_rate=0.001\n", + "Epoch 27/125 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.61241072, rnn_1step_R2_maskV_-1.0=0.36617655, rnn_1step_CC_maskV_-1.0=0.62274665, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.67790538, val_rnn_1step_R2_maskV_-1.0=0.22541055, val_rnn_1step_CC_maskV_-1.0=0.55087328, learning_rate=0.001\n", + "Epoch 40/125 - loss=rnn_1step_loss=0.53688008, rnn_1step_R2_maskV_-1.0=0.44452095, rnn_1step_CC_maskV_-1.0=0.67992884, rnn_1step_MSE_maskV_-1.0=0.53688014, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63675356, val_rnn_1step_R2_maskV_-1.0=0.27283257, val_rnn_1step_CC_maskV_-1.0=0.5898844, learning_rate=0.001\n", + "Epoch 53/125 - loss=rnn_1step_loss=0.49486449, rnn_1step_R2_maskV_-1.0=0.48785615, rnn_1step_CC_maskV_-1.0=0.70943356, rnn_1step_MSE_maskV_-1.0=0.49486452, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61214644, val_rnn_1step_R2_maskV_-1.0=0.30061668, val_rnn_1step_CC_maskV_-1.0=0.61092615, learning_rate=0.001\n", + "Epoch 66/125 - loss=rnn_1step_loss=0.46814558, rnn_1step_R2_maskV_-1.0=0.51516324, rnn_1step_CC_maskV_-1.0=0.72848094, rnn_1step_MSE_maskV_-1.0=0.46814555, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58124232, val_rnn_1step_R2_maskV_-1.0=0.33508077, val_rnn_1step_CC_maskV_-1.0=0.62990159, learning_rate=0.001\n", + "Epoch 79/125 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.45125404, rnn_1step_R2_maskV_-1.0=0.53266281, rnn_1step_CC_maskV_-1.0=0.74158466, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56066537, val_rnn_1step_R2_maskV_-1.0=0.35739863, val_rnn_1step_CC_maskV_-1.0=0.64438105, learning_rate=0.001\n", + "Epoch 92/125 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42771062, rnn_1step_R2_maskV_-1.0=0.55721498, rnn_1step_CC_maskV_-1.0=0.75660229, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55202299, val_rnn_1step_R2_maskV_-1.0=0.36643341, val_rnn_1step_CC_maskV_-1.0=0.65189248, learning_rate=0.001\n", + "Epoch 105/125 - loss=rnn_1step_loss=0.41429806, rnn_1step_R2_maskV_-1.0=0.57047445, rnn_1step_CC_maskV_-1.0=0.76433158, rnn_1step_MSE_maskV_-1.0=0.41429809, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57446861, val_rnn_1step_R2_maskV_-1.0=0.34028846, val_rnn_1step_CC_maskV_-1.0=0.64315695, learning_rate=0.001\n", + "Epoch 118/125 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39831683, rnn_1step_R2_maskV_-1.0=0.58729166, rnn_1step_CC_maskV_-1.0=0.77466428, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56440735, val_rnn_1step_R2_maskV_-1.0=0.35134906, val_rnn_1step_CC_maskV_-1.0=0.65385717, learning_rate=0.001\n", + "Epoch 125/125 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3910549, rnn_1step_R2_maskV_-1.0=0.59487557, rnn_1step_CC_maskV_-1.0=0.77876484, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57334614, val_rnn_1step_R2_maskV_-1.0=0.34121996, val_rnn_1step_CC_maskV_-1.0=0.65233082, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:05:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.76s\n", + "\u001b[32m2025-05-30 15:05:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:05:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 121 (stopped at 136 epochs).\n", + "\u001b[32m2025-05-30 15:05:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/137 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.99889606, rnn_1_1step_R2_maskV_-1.0=-0.021794353, rnn_1_1step_CC_maskV_-1.0=0.087237999, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96408206, val_rnn_1_1step_R2_maskV_-1.0=-0.086787447, val_rnn_1_1step_CC_maskV_-1.0=0.32277369, learning_rate=0.001\n", + "Epoch 15/137 - loss=rnn_1_1step_loss=0.77748233, rnn_1_1step_R2_maskV_-1.0=0.19755378, rnn_1_1step_CC_maskV_-1.0=0.47431096, rnn_1_1step_MSE_maskV_-1.0=0.77748245, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.76649761, val_rnn_1_1step_R2_maskV_-1.0=0.1227134, val_rnn_1_1step_CC_maskV_-1.0=0.4552919, learning_rate=0.001\n", + "Epoch 29/137 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.59792715, rnn_1_1step_R2_maskV_-1.0=0.37984693, rnn_1_1step_CC_maskV_-1.0=0.63432181, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65415359, val_rnn_1_1step_R2_maskV_-1.0=0.25237536, val_rnn_1_1step_CC_maskV_-1.0=0.57217366, learning_rate=0.001\n", + "Epoch 43/137 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.51602995, rnn_1_1step_R2_maskV_-1.0=0.46618682, rnn_1_1step_CC_maskV_-1.0=0.69512355, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61593509, val_rnn_1_1step_R2_maskV_-1.0=0.2952449, val_rnn_1_1step_CC_maskV_-1.0=0.60885543, learning_rate=0.001\n", + "Epoch 57/137 - loss=rnn_1_1step_loss=0.47813758, rnn_1_1step_R2_maskV_-1.0=0.50542611, rnn_1_1step_CC_maskV_-1.0=0.72148097, rnn_1_1step_MSE_maskV_-1.0=0.47813755, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59722489, val_rnn_1_1step_R2_maskV_-1.0=0.3169581, val_rnn_1_1step_CC_maskV_-1.0=0.62270892, learning_rate=0.001\n", + "Epoch 71/137 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.45662355, rnn_1_1step_R2_maskV_-1.0=0.5276165, rnn_1_1step_CC_maskV_-1.0=0.73624575, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59019011, val_rnn_1_1step_R2_maskV_-1.0=0.32408893, val_rnn_1_1step_CC_maskV_-1.0=0.62912798, learning_rate=0.001\n", + "Epoch 85/137 - loss=rnn_1_1step_loss=0.43732247, rnn_1_1step_R2_maskV_-1.0=0.54736173, rnn_1_1step_CC_maskV_-1.0=0.74918336, rnn_1_1step_MSE_maskV_-1.0=0.43732241, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58419818, val_rnn_1_1step_R2_maskV_-1.0=0.33034852, val_rnn_1_1step_CC_maskV_-1.0=0.6360234, learning_rate=0.001\n", + "Epoch 99/137 - loss=rnn_1_1step_loss=0.42840922, rnn_1_1step_R2_maskV_-1.0=0.55647922, rnn_1_1step_CC_maskV_-1.0=0.75693947, rnn_1_1step_MSE_maskV_-1.0=0.42840925, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54254681, val_rnn_1_1step_R2_maskV_-1.0=0.37807173, val_rnn_1_1step_CC_maskV_-1.0=0.66046739, learning_rate=0.001\n", + "Epoch 113/137 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39987114, rnn_1_1step_R2_maskV_-1.0=0.5862968, rnn_1_1step_CC_maskV_-1.0=0.77368921, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53124189, val_rnn_1_1step_R2_maskV_-1.0=0.38835353, val_rnn_1_1step_CC_maskV_-1.0=0.67856115, learning_rate=0.001\n", + "Epoch 127/137 - loss=rnn_1_1step_loss=0.38193306, rnn_1_1step_R2_maskV_-1.0=0.60523528, rnn_1_1step_CC_maskV_-1.0=0.78565246, rnn_1_1step_MSE_maskV_-1.0=0.38193303, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52089268, val_rnn_1_1step_R2_maskV_-1.0=0.39880961, val_rnn_1_1step_CC_maskV_-1.0=0.6904611, learning_rate=0.001\n", + "Epoch 137/137 - loss=rnn_1_1step_loss=0.36799034, rnn_1_1step_R2_maskV_-1.0=0.61945736, rnn_1_1step_CC_maskV_-1.0=0.79351318, rnn_1_1step_MSE_maskV_-1.0=0.36799031, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52840453, val_rnn_1_1step_R2_maskV_-1.0=0.38942519, val_rnn_1_1step_CC_maskV_-1.0=0.69071281, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:05:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 16.93s\n", + "\u001b[32m2025-05-30 15:05:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.50166029)\n", + "\u001b[32m2025-05-30 15:06:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.389, R2_maskV_-1.0=0.611, CC_maskV_-1.0=0.785\n", + "\u001b[32m2025-05-30 15:06:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.499, R2_maskV_-1.0=0.44, CC_maskV_-1.0=0.702\n", + "\u001b[32m2025-05-30 15:06:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:06:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:06:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 147 (stopped at 162 epochs).\n", + "\u001b[32m2025-05-30 15:06:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/163 - loss=1.0351359, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.23141852, MSE_maskV_-1.0=1.0363098, val_loss=0.87237912, val_CC_maskV_-1.0=0.36591417, val_MSE_maskV_-1.0=0.86908108, learning_rate=0.001\n", + "Epoch 18/163 - loss=0.6452629, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59324789, MSE_maskV_-1.0=0.64518964, val_loss=0.66835999, val_CC_maskV_-1.0=0.57641792, val_MSE_maskV_-1.0=0.66558671, learning_rate=0.001\n", + "Epoch 35/163 - loss=0.62130827, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61338532, MSE_maskV_-1.0=0.62113994, val_loss=0.65240002, val_CC_maskV_-1.0=0.59064931, val_MSE_maskV_-1.0=0.64932436, learning_rate=0.001\n", + "Epoch 52/163 - loss=0.60854888, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62302476, MSE_maskV_-1.0=0.60926604, val_loss=0.64329267, val_CC_maskV_-1.0=0.59807497, val_MSE_maskV_-1.0=0.64075786, learning_rate=0.001\n", + "Epoch 69/163 - loss=0.59902149, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63147777, MSE_maskV_-1.0=0.59920448, val_loss=0.63872552, val_CC_maskV_-1.0=0.60237306, val_MSE_maskV_-1.0=0.63593435, learning_rate=0.001\n", + "Epoch 86/163 - loss=0.59209949, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63604379, MSE_maskV_-1.0=0.59192371, val_loss=0.63609248, val_CC_maskV_-1.0=0.60429597, val_MSE_maskV_-1.0=0.6332438, learning_rate=0.001\n", + "Epoch 103/163 - loss=0.58705282, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63923091, MSE_maskV_-1.0=0.58682513, val_loss=0.63274831, val_CC_maskV_-1.0=0.60796028, val_MSE_maskV_-1.0=0.62984389, learning_rate=0.001\n", + "Epoch 120/163 - loss=0.58336776, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64229518, MSE_maskV_-1.0=0.58349812, val_loss=0.62940204, val_CC_maskV_-1.0=0.61018574, val_MSE_maskV_-1.0=0.6264264, learning_rate=0.001\n", + "Epoch 137/163 - loss=0.58030546, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64545512, MSE_maskV_-1.0=0.57999319, val_loss=0.62941831, val_CC_maskV_-1.0=0.61082602, val_MSE_maskV_-1.0=0.62633771, learning_rate=0.001\n", + "Epoch 154/163 - loss=0.5779264, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64676738, MSE_maskV_-1.0=0.57786149, val_loss=0.62819052, val_CC_maskV_-1.0=0.61175376, val_MSE_maskV_-1.0=0.62536538, learning_rate=0.001\n", + "Epoch 163/163 - loss=0.5769068, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64758849, MSE_maskV_-1.0=0.57662213, val_loss=0.63199323, val_CC_maskV_-1.0=0.6089316, val_MSE_maskV_-1.0=0.62926126, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:06:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 42.35s\n", + "\u001b[32m2025-05-30 15:06:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:07:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 147 (stopped at 162 epochs).\n", + "\u001b[32m2025-05-30 15:07:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/163 - loss=0.97877944, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.24777229, MSE_maskV_-1.0=0.97989786, val_loss=0.85150182, val_CC_maskV_-1.0=0.39138365, val_MSE_maskV_-1.0=0.84901422, learning_rate=0.001\n", + "Epoch 18/163 - loss=0.63836074, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59881878, MSE_maskV_-1.0=0.6383093, val_loss=0.66137648, val_CC_maskV_-1.0=0.58102733, val_MSE_maskV_-1.0=0.65925419, learning_rate=0.001\n", + "Epoch 35/163 - loss=0.61423844, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61912513, MSE_maskV_-1.0=0.61403579, val_loss=0.64641583, val_CC_maskV_-1.0=0.59451038, val_MSE_maskV_-1.0=0.64393312, learning_rate=0.001\n", + "Epoch 52/163 - loss=0.60218221, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6281836, MSE_maskV_-1.0=0.60281432, val_loss=0.63693327, val_CC_maskV_-1.0=0.60187906, val_MSE_maskV_-1.0=0.63513976, learning_rate=0.001\n", + "Epoch 69/163 - loss=0.5945518, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63479453, MSE_maskV_-1.0=0.59478319, val_loss=0.63076186, val_CC_maskV_-1.0=0.60818529, val_MSE_maskV_-1.0=0.6285454, learning_rate=0.001\n", + "Epoch 86/163 - loss=0.58943492, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63827735, MSE_maskV_-1.0=0.58934391, val_loss=0.6321401, val_CC_maskV_-1.0=0.60742724, val_MSE_maskV_-1.0=0.62973982, learning_rate=0.001\n", + "Epoch 103/163 - loss=0.58600044, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64020276, MSE_maskV_-1.0=0.58574247, val_loss=0.63034934, val_CC_maskV_-1.0=0.6101141, val_MSE_maskV_-1.0=0.62753385, learning_rate=0.001\n", + "Epoch 120/163 - loss=0.5829379, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64264518, MSE_maskV_-1.0=0.58329111, val_loss=0.62726647, val_CC_maskV_-1.0=0.6121394, val_MSE_maskV_-1.0=0.62446404, learning_rate=0.001\n", + "Epoch 137/163 - loss=0.58081627, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64513052, MSE_maskV_-1.0=0.58038998, val_loss=0.62770665, val_CC_maskV_-1.0=0.61228633, val_MSE_maskV_-1.0=0.62460774, learning_rate=0.001\n", + "Epoch 154/163 - loss=0.57869959, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64634418, MSE_maskV_-1.0=0.5785706, val_loss=0.6292603, val_CC_maskV_-1.0=0.61120528, val_MSE_maskV_-1.0=0.62611043, learning_rate=0.001\n", + "Epoch 163/163 - loss=0.57784498, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64695799, MSE_maskV_-1.0=0.57754731, val_loss=0.63035995, val_CC_maskV_-1.0=0.61042994, val_MSE_maskV_-1.0=0.62773681, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:07:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 42.00s\n", + "\u001b[32m2025-05-30 15:07:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.62470549)\n", + "\u001b[32m2025-05-30 15:07:24\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 744us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:07:25\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.576, R2_maskV_-1.0=0.426, CC_maskV_-1.0=0.651\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 735us/step\n", + "51/51 [==============================] - 0s 759us/step\n", + "84/84 [==============================] - 0s 762us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:07:25\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_ACzCy1HL64U_ErSV16\" (14/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_ACzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:07:25\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_KCzCy1HL64U_ErSV16\" (15/16)\n", + "\u001b[32m2025-05-30 15:07:25\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:07:25\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:07:25\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:07:26\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:07:26\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:07:26\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:07:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:07:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 114 (stopped at 129 epochs).\n", + "\u001b[32m2025-05-30 15:07:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/130 - loss=rnn_1step_loss=0.99952751, rnn_1step_R2_maskV_-1.0=-0.022459906, rnn_1step_CC_maskV_-1.0=-0.012578293, rnn_1step_MSE_maskV_-1.0=0.99952757, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96604162, val_rnn_1step_R2_maskV_-1.0=-0.088933349, val_rnn_1step_CC_maskV_-1.0=0.18618314, learning_rate=0.001\n", + "Epoch 14/130 - loss=rnn_1step_loss=0.74332458, rnn_1step_R2_maskV_-1.0=0.23256025, rnn_1step_CC_maskV_-1.0=0.50797606, rnn_1step_MSE_maskV_-1.0=0.74332464, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.74738485, val_rnn_1step_R2_maskV_-1.0=0.14514095, val_rnn_1step_CC_maskV_-1.0=0.4931885, learning_rate=0.001\n", + "Epoch 27/130 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.5631724, rnn_1step_R2_maskV_-1.0=0.41323948, rnn_1step_CC_maskV_-1.0=0.66177183, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64360422, val_rnn_1step_R2_maskV_-1.0=0.2644915, val_rnn_1step_CC_maskV_-1.0=0.59040266, learning_rate=0.001\n", + "Epoch 40/130 - loss=rnn_1step_loss=0.47256956, rnn_1step_R2_maskV_-1.0=0.50629699, rnn_1step_CC_maskV_-1.0=0.7266295, rnn_1step_MSE_maskV_-1.0=0.47256958, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59925121, val_rnn_1step_R2_maskV_-1.0=0.31791538, val_rnn_1step_CC_maskV_-1.0=0.62819684, learning_rate=0.001\n", + "Epoch 53/130 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39721379, rnn_1step_R2_maskV_-1.0=0.58599889, rnn_1step_CC_maskV_-1.0=0.77605903, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57231951, val_rnn_1step_R2_maskV_-1.0=0.35036939, val_rnn_1step_CC_maskV_-1.0=0.65131819, learning_rate=0.001\n", + "Epoch 66/130 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34817186, rnn_1step_R2_maskV_-1.0=0.63816023, rnn_1step_CC_maskV_-1.0=0.80678046, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56991291, val_rnn_1step_R2_maskV_-1.0=0.3540847, val_rnn_1step_CC_maskV_-1.0=0.65705281, learning_rate=0.001\n", + "Epoch 79/130 - loss=rnn_1step_loss=0.30679074, rnn_1step_R2_maskV_-1.0=0.68192875, rnn_1step_CC_maskV_-1.0=0.83187634, rnn_1step_MSE_maskV_-1.0=0.30679071, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55218542, val_rnn_1step_R2_maskV_-1.0=0.37342471, val_rnn_1step_CC_maskV_-1.0=0.6723395, learning_rate=0.001\n", + "Epoch 92/130 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27495885, rnn_1step_R2_maskV_-1.0=0.71517754, rnn_1step_CC_maskV_-1.0=0.85074675, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52738017, val_rnn_1step_R2_maskV_-1.0=0.40029207, val_rnn_1step_CC_maskV_-1.0=0.68949354, learning_rate=0.001\n", + "Epoch 105/130 - loss=rnn_1step_loss=0.25123742, rnn_1step_R2_maskV_-1.0=0.73991621, rnn_1step_CC_maskV_-1.0=0.86444438, rnn_1step_MSE_maskV_-1.0=0.25123739, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50746685, val_rnn_1step_R2_maskV_-1.0=0.42208162, val_rnn_1step_CC_maskV_-1.0=0.70246559, learning_rate=0.001\n", + "Epoch 118/130 - loss=rnn_1step_loss=0.23330687, rnn_1step_R2_maskV_-1.0=0.75836128, rnn_1step_CC_maskV_-1.0=0.87474835, rnn_1step_MSE_maskV_-1.0=0.23330688, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50163019, val_rnn_1step_R2_maskV_-1.0=0.42872798, val_rnn_1step_CC_maskV_-1.0=0.70620793, learning_rate=0.001\n", + "Epoch 130/130 - loss=rnn_1step_loss=0.22274762, rnn_1step_R2_maskV_-1.0=0.76912344, rnn_1step_CC_maskV_-1.0=0.88079059, rnn_1step_MSE_maskV_-1.0=0.22274761, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50056547, val_rnn_1step_R2_maskV_-1.0=0.42964596, val_rnn_1step_CC_maskV_-1.0=0.70740837, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:07:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.88s\n", + "\u001b[32m2025-05-30 15:07:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:07:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 124 (stopped at 139 epochs).\n", + "\u001b[32m2025-05-30 15:07:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/140 - loss=rnn_1_1step_loss=0.99942136, rnn_1_1step_R2_maskV_-1.0=-0.022344045, rnn_1_1step_CC_maskV_-1.0=0.025116391, rnn_1_1step_MSE_maskV_-1.0=0.99942142, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96552497, val_rnn_1_1step_R2_maskV_-1.0=-0.088323593, val_rnn_1_1step_CC_maskV_-1.0=0.2938081, learning_rate=0.001\n", + "Epoch 15/140 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.73571539, rnn_1_1step_R2_maskV_-1.0=0.24219364, rnn_1_1step_CC_maskV_-1.0=0.51753885, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.74389392, val_rnn_1_1step_R2_maskV_-1.0=0.15272541, val_rnn_1_1step_CC_maskV_-1.0=0.48071408, learning_rate=0.001\n", + "Epoch 29/140 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.61173558, rnn_1_1step_R2_maskV_-1.0=0.36519322, rnn_1_1step_CC_maskV_-1.0=0.62199724, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.70603442, val_rnn_1_1step_R2_maskV_-1.0=0.19790015, val_rnn_1_1step_CC_maskV_-1.0=0.52915931, learning_rate=0.001\n", + "Epoch 43/140 - loss=rnn_1_1step_loss=0.52845067, rnn_1_1step_R2_maskV_-1.0=0.45477989, rnn_1_1step_CC_maskV_-1.0=0.68471265, rnn_1_1step_MSE_maskV_-1.0=0.52845061, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64768392, val_rnn_1_1step_R2_maskV_-1.0=0.26385659, val_rnn_1_1step_CC_maskV_-1.0=0.58040589, learning_rate=0.001\n", + "Epoch 57/140 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44346151, rnn_1_1step_R2_maskV_-1.0=0.54232323, rnn_1_1step_CC_maskV_-1.0=0.74400699, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57816893, val_rnn_1_1step_R2_maskV_-1.0=0.34079191, val_rnn_1_1step_CC_maskV_-1.0=0.64226204, learning_rate=0.001\n", + "Epoch 71/140 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38464996, rnn_1_1step_R2_maskV_-1.0=0.60234833, rnn_1_1step_CC_maskV_-1.0=0.78281182, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54382163, val_rnn_1_1step_R2_maskV_-1.0=0.37874463, val_rnn_1_1step_CC_maskV_-1.0=0.67221153, learning_rate=0.001\n", + "Epoch 85/140 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32572827, rnn_1_1step_R2_maskV_-1.0=0.66268319, rnn_1_1step_CC_maskV_-1.0=0.82026905, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50527424, val_rnn_1_1step_R2_maskV_-1.0=0.42218879, val_rnn_1_1step_CC_maskV_-1.0=0.7011382, learning_rate=0.001\n", + "Epoch 99/140 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.27858973, rnn_1_1step_R2_maskV_-1.0=0.71184266, rnn_1_1step_CC_maskV_-1.0=0.84814239, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49022594, val_rnn_1_1step_R2_maskV_-1.0=0.43975782, val_rnn_1_1step_CC_maskV_-1.0=0.71245372, learning_rate=0.001\n", + "Epoch 113/140 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.25329024, rnn_1_1step_R2_maskV_-1.0=0.73811281, rnn_1_1step_CC_maskV_-1.0=0.86314899, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47710288, val_rnn_1_1step_R2_maskV_-1.0=0.45535052, val_rnn_1_1step_CC_maskV_-1.0=0.71977049, learning_rate=0.001\n", + "Epoch 127/140 - loss=rnn_1_1step_loss=0.22761638, rnn_1_1step_R2_maskV_-1.0=0.76484156, rnn_1_1step_CC_maskV_-1.0=0.8780278, rnn_1_1step_MSE_maskV_-1.0=0.22761637, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50043601, val_rnn_1_1step_R2_maskV_-1.0=0.42821479, val_rnn_1_1step_CC_maskV_-1.0=0.71237403, learning_rate=0.001\n", + "Epoch 140/140 - loss=rnn_1_1step_loss=0.20558803, rnn_1_1step_R2_maskV_-1.0=0.78726697, rnn_1_1step_CC_maskV_-1.0=0.890728, rnn_1_1step_MSE_maskV_-1.0=0.20558801, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47780433, val_rnn_1_1step_R2_maskV_-1.0=0.45510912, val_rnn_1_1step_CC_maskV_-1.0=0.72287792, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:07:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.85s\n", + "\u001b[32m2025-05-30 15:07:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.46894121)\n", + "\u001b[32m2025-05-30 15:07:58\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.216, R2_maskV_-1.0=0.784, CC_maskV_-1.0=0.886\n", + "\u001b[32m2025-05-30 15:07:58\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.436, R2_maskV_-1.0=0.518, CC_maskV_-1.0=0.751\n", + "\u001b[32m2025-05-30 15:07:58\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:07:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:08:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 189 (stopped at 204 epochs).\n", + "\u001b[32m2025-05-30 15:08:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/205 - loss=1.0998704, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.12968384, MSE_maskV_-1.0=1.1015686, val_loss=0.95568073, val_CC_maskV_-1.0=0.2303673, val_MSE_maskV_-1.0=0.9509089, learning_rate=0.001\n", + "Epoch 22/205 - loss=0.78595191, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46259612, MSE_maskV_-1.0=0.78641284, val_loss=0.79824346, val_CC_maskV_-1.0=0.44999844, val_MSE_maskV_-1.0=0.79676032, learning_rate=0.001\n", + "Epoch 43/205 - loss=0.75256497, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49709463, MSE_maskV_-1.0=0.75290227, val_loss=0.77042943, val_CC_maskV_-1.0=0.48023233, val_MSE_maskV_-1.0=0.76883441, learning_rate=0.001\n", + "Epoch 64/205 - loss=0.73673379, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51249039, MSE_maskV_-1.0=0.73652381, val_loss=0.75826275, val_CC_maskV_-1.0=0.49317288, val_MSE_maskV_-1.0=0.75540268, learning_rate=0.001\n", + "Epoch 85/205 - loss=0.72642595, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52187747, MSE_maskV_-1.0=0.72646868, val_loss=0.74695438, val_CC_maskV_-1.0=0.503986, val_MSE_maskV_-1.0=0.74422312, learning_rate=0.001\n", + "Epoch 106/205 - loss=0.71834648, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52927631, MSE_maskV_-1.0=0.71772021, val_loss=0.74220127, val_CC_maskV_-1.0=0.50806451, val_MSE_maskV_-1.0=0.73958939, learning_rate=0.001\n", + "Epoch 127/205 - loss=0.71124917, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53469282, MSE_maskV_-1.0=0.7131179, val_loss=0.73863643, val_CC_maskV_-1.0=0.51128292, val_MSE_maskV_-1.0=0.73592383, learning_rate=0.001\n", + "Epoch 148/205 - loss=0.70809692, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53849107, MSE_maskV_-1.0=0.70973343, val_loss=0.73386252, val_CC_maskV_-1.0=0.51575142, val_MSE_maskV_-1.0=0.73091525, learning_rate=0.001\n", + "Epoch 169/205 - loss=0.70301455, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54339218, MSE_maskV_-1.0=0.7030378, val_loss=0.73299378, val_CC_maskV_-1.0=0.51679689, val_MSE_maskV_-1.0=0.73022759, learning_rate=0.001\n", + "Epoch 190/205 - loss=0.69998622, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54511583, MSE_maskV_-1.0=0.69954455, val_loss=0.73232371, val_CC_maskV_-1.0=0.51542801, val_MSE_maskV_-1.0=0.73036963, learning_rate=0.001\n", + "Epoch 205/205 - loss=0.69888109, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54758787, MSE_maskV_-1.0=0.69822949, val_loss=0.73202032, val_CC_maskV_-1.0=0.51612782, val_MSE_maskV_-1.0=0.73079944, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:08:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 51.99s\n", + "\u001b[32m2025-05-30 15:08:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:09:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 169 (stopped at 184 epochs).\n", + "\u001b[32m2025-05-30 15:09:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/185 - loss=1.136705, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.12683219, MSE_maskV_-1.0=1.1382004, val_loss=0.96153313, val_CC_maskV_-1.0=0.21701141, val_MSE_maskV_-1.0=0.95793074, learning_rate=0.001\n", + "Epoch 20/185 - loss=0.79262549, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.456478, MSE_maskV_-1.0=0.79249185, val_loss=0.80422467, val_CC_maskV_-1.0=0.44470188, val_MSE_maskV_-1.0=0.80265784, learning_rate=0.001\n", + "Epoch 39/185 - loss=0.756392, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49318838, MSE_maskV_-1.0=0.75672847, val_loss=0.7751714, val_CC_maskV_-1.0=0.47522762, val_MSE_maskV_-1.0=0.77271533, learning_rate=0.001\n", + "Epoch 58/185 - loss=0.73817241, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51142114, MSE_maskV_-1.0=0.7375533, val_loss=0.75949764, val_CC_maskV_-1.0=0.49033651, val_MSE_maskV_-1.0=0.75798953, learning_rate=0.001\n", + "Epoch 77/185 - loss=0.72662616, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52208, MSE_maskV_-1.0=0.72612977, val_loss=0.74511701, val_CC_maskV_-1.0=0.50626862, val_MSE_maskV_-1.0=0.74279433, learning_rate=0.001\n", + "Epoch 96/185 - loss=0.71864557, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5291127, MSE_maskV_-1.0=0.71844929, val_loss=0.74332517, val_CC_maskV_-1.0=0.50689983, val_MSE_maskV_-1.0=0.74069363, learning_rate=0.001\n", + "Epoch 115/185 - loss=0.71259201, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53517509, MSE_maskV_-1.0=0.71237397, val_loss=0.74223131, val_CC_maskV_-1.0=0.50793421, val_MSE_maskV_-1.0=0.74122268, learning_rate=0.001\n", + "Epoch 134/185 - loss=0.70799816, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53882897, MSE_maskV_-1.0=0.70786047, val_loss=0.73601311, val_CC_maskV_-1.0=0.51165831, val_MSE_maskV_-1.0=0.73545408, learning_rate=0.001\n", + "Epoch 153/185 - loss=0.70369059, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5431211, MSE_maskV_-1.0=0.70317155, val_loss=0.7363953, val_CC_maskV_-1.0=0.51246089, val_MSE_maskV_-1.0=0.73426843, learning_rate=0.001\n", + "Epoch 172/185 - loss=0.7007255, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54573554, MSE_maskV_-1.0=0.70164341, val_loss=0.73205203, val_CC_maskV_-1.0=0.51601744, val_MSE_maskV_-1.0=0.73194534, learning_rate=0.001\n", + "Epoch 185/185 - loss=0.70013702, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54602039, MSE_maskV_-1.0=0.70056337, val_loss=0.73613346, val_CC_maskV_-1.0=0.51293921, val_MSE_maskV_-1.0=0.73395294, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:09:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 46.90s\n", + "\u001b[32m2025-05-30 15:09:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.72844875)\n", + "\u001b[32m2025-05-30 15:09:37\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 763us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:09:37\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.696, R2_maskV_-1.0=0.306, CC_maskV_-1.0=0.552\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 760us/step\n", + "51/51 [==============================] - 0s 755us/step\n", + "84/84 [==============================] - 0s 685us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:09:38\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_KCzCy1HL64U_ErSV16\" (15/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_KCzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:09:38\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 1/4 method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16\" (16/16)\n", + "\u001b[32m2025-05-30 15:09:38\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:09:38\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:09:38\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:09:38\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:09:38\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:09:38\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:09:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:09:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 90 (stopped at 105 epochs).\n", + "\u001b[32m2025-05-30 15:09:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/106 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.99943799, rnn_1step_R2_maskV_-1.0=-0.022367138, rnn_1step_CC_maskV_-1.0=0.040245987, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.96533442, val_rnn_1step_R2_maskV_-1.0=-0.088089943, val_rnn_1step_CC_maskV_-1.0=0.27749488, learning_rate=0.001\n", + "Epoch 12/106 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.85660356, rnn_1step_R2_maskV_-1.0=0.12077586, rnn_1step_CC_maskV_-1.0=0.3799597, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.82071596, val_rnn_1step_R2_maskV_-1.0=0.069990307, val_rnn_1step_CC_maskV_-1.0=0.41432819, learning_rate=0.001\n", + "Epoch 23/106 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.72083873, rnn_1step_R2_maskV_-1.0=0.25819069, rnn_1step_CC_maskV_-1.0=0.53154278, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.70265132, val_rnn_1step_R2_maskV_-1.0=0.2030908, val_rnn_1step_CC_maskV_-1.0=0.52486485, learning_rate=0.001\n", + "Epoch 34/106 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.55271745, rnn_1step_R2_maskV_-1.0=0.42480823, rnn_1step_CC_maskV_-1.0=0.67089581, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61349839, val_rnn_1step_R2_maskV_-1.0=0.29894084, val_rnn_1step_CC_maskV_-1.0=0.60266697, learning_rate=0.001\n", + "Epoch 45/106 - loss=rnn_1step_loss=0.47148135, rnn_1step_R2_maskV_-1.0=0.50759554, rnn_1step_CC_maskV_-1.0=0.72705829, rnn_1step_MSE_maskV_-1.0=0.47148138, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56691933, val_rnn_1step_R2_maskV_-1.0=0.3530376, val_rnn_1step_CC_maskV_-1.0=0.64056736, learning_rate=0.001\n", + "Epoch 56/106 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41377053, rnn_1step_R2_maskV_-1.0=0.5685156, rnn_1step_CC_maskV_-1.0=0.76408988, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5449453, val_rnn_1step_R2_maskV_-1.0=0.37719563, val_rnn_1step_CC_maskV_-1.0=0.66031909, learning_rate=0.001\n", + "Epoch 67/106 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.36306703, rnn_1step_R2_maskV_-1.0=0.6221171, rnn_1step_CC_maskV_-1.0=0.79707003, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53998357, val_rnn_1step_R2_maskV_-1.0=0.38187617, val_rnn_1step_CC_maskV_-1.0=0.6702224, learning_rate=0.001\n", + "Epoch 78/106 - loss=rnn_1step_loss=0.33936453, rnn_1step_R2_maskV_-1.0=0.64648026, rnn_1step_CC_maskV_-1.0=0.81265628, rnn_1step_MSE_maskV_-1.0=0.3393645, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51323128, val_rnn_1step_R2_maskV_-1.0=0.41418993, val_rnn_1step_CC_maskV_-1.0=0.68391973, learning_rate=0.001\n", + "Epoch 89/106 - loss=rnn_1step_loss=0.31457269, rnn_1step_R2_maskV_-1.0=0.67249542, rnn_1step_CC_maskV_-1.0=0.82759798, rnn_1step_MSE_maskV_-1.0=0.31457272, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52310306, val_rnn_1step_R2_maskV_-1.0=0.40205348, val_rnn_1step_CC_maskV_-1.0=0.68303305, learning_rate=0.001\n", + "Epoch 100/106 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30052638, rnn_1step_R2_maskV_-1.0=0.68700826, rnn_1step_CC_maskV_-1.0=0.83590555, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5114975, val_rnn_1step_R2_maskV_-1.0=0.41605145, val_rnn_1step_CC_maskV_-1.0=0.68701357, learning_rate=0.001\n", + "Epoch 106/106 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29080719, rnn_1step_R2_maskV_-1.0=0.69723344, rnn_1step_CC_maskV_-1.0=0.84160691, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52896196, val_rnn_1step_R2_maskV_-1.0=0.39422038, val_rnn_1step_CC_maskV_-1.0=0.68076909, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:09:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 13.56s\n", + "\u001b[32m2025-05-30 15:09:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:09:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 27 (stopped at 42 epochs).\n", + "\u001b[32m2025-05-30 15:09:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/43 - loss=rnn_1_1step_loss=0.99943739, rnn_1_1step_R2_maskV_-1.0=-0.022364665, rnn_1_1step_CC_maskV_-1.0=0.0094748437, rnn_1_1step_MSE_maskV_-1.0=0.99943733, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.96540648, val_rnn_1_1step_R2_maskV_-1.0=-0.088181123, val_rnn_1_1step_CC_maskV_-1.0=0.25226882, learning_rate=0.001\n", + "Epoch 6/43 - loss=rnn_1_1step_loss=0.98355371, rnn_1_1step_R2_maskV_-1.0=-0.0060114712, rnn_1_1step_CC_maskV_-1.0=0.30988276, rnn_1_1step_MSE_maskV_-1.0=0.98355377, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.93736166, val_rnn_1_1step_R2_maskV_-1.0=-0.057422847, val_rnn_1_1step_CC_maskV_-1.0=0.30077425, learning_rate=0.001\n", + "Epoch 11/43 - loss=rnn_1_1step_loss=0.86730796, rnn_1_1step_R2_maskV_-1.0=0.10868652, rnn_1_1step_CC_maskV_-1.0=0.3924574, rnn_1_1step_MSE_maskV_-1.0=0.86730802, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.81665784, val_rnn_1_1step_R2_maskV_-1.0=0.07063441, val_rnn_1_1step_CC_maskV_-1.0=0.37888688, learning_rate=0.001\n", + "Epoch 16/43 - loss=rnn_1_1step_loss=0.71582651, rnn_1_1step_R2_maskV_-1.0=0.25881109, rnn_1_1step_CC_maskV_-1.0=0.53310609, rnn_1_1step_MSE_maskV_-1.0=0.71582657, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.73286033, val_rnn_1_1step_R2_maskV_-1.0=0.16226089, val_rnn_1_1step_CC_maskV_-1.0=0.48536432, learning_rate=0.001\n", + "Epoch 21/43 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.66000688, rnn_1_1step_R2_maskV_-1.0=0.3125082, rnn_1_1step_CC_maskV_-1.0=0.58166504, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.72477698, val_rnn_1_1step_R2_maskV_-1.0=0.17113145, val_rnn_1_1step_CC_maskV_-1.0=0.50835425, learning_rate=0.001\n", + "Epoch 26/43 - loss=rnn_1_1step_loss=0.63607478, rnn_1_1step_R2_maskV_-1.0=0.33649075, rnn_1_1step_CC_maskV_-1.0=0.60078824, rnn_1_1step_MSE_maskV_-1.0=0.63607472, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.71284801, val_rnn_1_1step_R2_maskV_-1.0=0.18469714, val_rnn_1_1step_CC_maskV_-1.0=0.52048087, learning_rate=0.001\n", + "Epoch 31/43 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.62141055, rnn_1_1step_R2_maskV_-1.0=0.35097694, rnn_1_1step_CC_maskV_-1.0=0.61349988, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.71235436, val_rnn_1_1step_R2_maskV_-1.0=0.18630829, val_rnn_1_1step_CC_maskV_-1.0=0.51869297, learning_rate=0.001\n", + "Epoch 36/43 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.60810566, rnn_1_1step_R2_maskV_-1.0=0.36418974, rnn_1_1step_CC_maskV_-1.0=0.62451112, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.71392983, val_rnn_1_1step_R2_maskV_-1.0=0.1853276, val_rnn_1_1step_CC_maskV_-1.0=0.51650631, learning_rate=0.001\n", + "Epoch 41/43 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.59313458, rnn_1_1step_R2_maskV_-1.0=0.37957734, rnn_1_1step_CC_maskV_-1.0=0.63618177, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.71418303, val_rnn_1_1step_R2_maskV_-1.0=0.1854881, val_rnn_1_1step_CC_maskV_-1.0=0.51653165, learning_rate=0.001\n", + "Epoch 43/43 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.58603001, rnn_1_1step_R2_maskV_-1.0=0.38694662, rnn_1_1step_CC_maskV_-1.0=0.64181256, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.71366757, val_rnn_1_1step_R2_maskV_-1.0=0.18629584, val_rnn_1_1step_CC_maskV_-1.0=0.51699096, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:09:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 6.97s\n", + "\u001b[32m2025-05-30 15:09:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.50742292)\n", + "\u001b[32m2025-05-30 15:10:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.297, R2_maskV_-1.0=0.703, CC_maskV_-1.0=0.839\n", + "\u001b[32m2025-05-30 15:10:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.485, R2_maskV_-1.0=0.461, CC_maskV_-1.0=0.71\n", + "\u001b[32m2025-05-30 15:10:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:10:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:10:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 157 (stopped at 172 epochs).\n", + "\u001b[32m2025-05-30 15:10:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/173 - loss=1.0516784, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.17025764, MSE_maskV_-1.0=1.0534121, val_loss=0.93290824, val_CC_maskV_-1.0=0.27886954, val_MSE_maskV_-1.0=0.92934322, learning_rate=0.001\n", + "Epoch 19/173 - loss=0.79966915, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4480367, MSE_maskV_-1.0=0.80028981, val_loss=0.81971645, val_CC_maskV_-1.0=0.43281731, val_MSE_maskV_-1.0=0.81692201, learning_rate=0.001\n", + "Epoch 37/173 - loss=0.7709744, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47810501, MSE_maskV_-1.0=0.77143812, val_loss=0.79605597, val_CC_maskV_-1.0=0.45756677, val_MSE_maskV_-1.0=0.79289752, learning_rate=0.001\n", + "Epoch 55/173 - loss=0.75382107, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49585012, MSE_maskV_-1.0=0.75312895, val_loss=0.78846151, val_CC_maskV_-1.0=0.46539, val_MSE_maskV_-1.0=0.78563052, learning_rate=0.001\n", + "Epoch 73/173 - loss=0.74309653, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50503987, MSE_maskV_-1.0=0.74277604, val_loss=0.78295952, val_CC_maskV_-1.0=0.46983933, val_MSE_maskV_-1.0=0.78034896, learning_rate=0.001\n", + "Epoch 91/173 - loss=0.73486519, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51428419, MSE_maskV_-1.0=0.73506147, val_loss=0.77546448, val_CC_maskV_-1.0=0.47784472, val_MSE_maskV_-1.0=0.77282542, learning_rate=0.001\n", + "Epoch 109/173 - loss=0.72793543, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51971304, MSE_maskV_-1.0=0.727539, val_loss=0.77054924, val_CC_maskV_-1.0=0.48300338, val_MSE_maskV_-1.0=0.76802993, learning_rate=0.001\n", + "Epoch 127/173 - loss=0.72183919, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52408463, MSE_maskV_-1.0=0.72353178, val_loss=0.77285403, val_CC_maskV_-1.0=0.48200196, val_MSE_maskV_-1.0=0.77035934, learning_rate=0.001\n", + "Epoch 145/173 - loss=0.71753991, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52875817, MSE_maskV_-1.0=0.71781063, val_loss=0.77029407, val_CC_maskV_-1.0=0.48327389, val_MSE_maskV_-1.0=0.76796424, learning_rate=0.001\n", + "Epoch 163/173 - loss=0.71375674, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53255349, MSE_maskV_-1.0=0.71341133, val_loss=0.77209657, val_CC_maskV_-1.0=0.48257026, val_MSE_maskV_-1.0=0.76923108, learning_rate=0.001\n", + "Epoch 173/173 - loss=0.71231067, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53352207, MSE_maskV_-1.0=0.71161079, val_loss=0.76540744, val_CC_maskV_-1.0=0.4884887, val_MSE_maskV_-1.0=0.76347053, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:10:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 44.38s\n", + "\u001b[32m2025-05-30 15:10:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:11:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 150 (stopped at 165 epochs).\n", + "\u001b[32m2025-05-30 15:11:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/166 - loss=1.1550447, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.13597822, MSE_maskV_-1.0=1.1564407, val_loss=0.951469, val_CC_maskV_-1.0=0.2443376, val_MSE_maskV_-1.0=0.94707793, learning_rate=0.001\n", + "Epoch 18/166 - loss=0.81096911, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43467283, MSE_maskV_-1.0=0.81096357, val_loss=0.82814205, val_CC_maskV_-1.0=0.42311636, val_MSE_maskV_-1.0=0.82506794, learning_rate=0.001\n", + "Epoch 35/166 - loss=0.78370446, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4650954, MSE_maskV_-1.0=0.78354299, val_loss=0.80731946, val_CC_maskV_-1.0=0.44317007, val_MSE_maskV_-1.0=0.80450153, learning_rate=0.001\n", + "Epoch 52/166 - loss=0.76577014, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48332635, MSE_maskV_-1.0=0.7663095, val_loss=0.79479462, val_CC_maskV_-1.0=0.45865631, val_MSE_maskV_-1.0=0.79214513, learning_rate=0.001\n", + "Epoch 69/166 - loss=0.75282902, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49682516, MSE_maskV_-1.0=0.75291038, val_loss=0.77851045, val_CC_maskV_-1.0=0.47474819, val_MSE_maskV_-1.0=0.77565461, learning_rate=0.001\n", + "Epoch 86/166 - loss=0.74196863, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50695366, MSE_maskV_-1.0=0.74175417, val_loss=0.77630419, val_CC_maskV_-1.0=0.47690114, val_MSE_maskV_-1.0=0.77384657, learning_rate=0.001\n", + "Epoch 103/166 - loss=0.73398429, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51386261, MSE_maskV_-1.0=0.7335934, val_loss=0.76755333, val_CC_maskV_-1.0=0.48588869, val_MSE_maskV_-1.0=0.76468229, learning_rate=0.001\n", + "Epoch 120/166 - loss=0.72830117, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51920277, MSE_maskV_-1.0=0.72851479, val_loss=0.7720415, val_CC_maskV_-1.0=0.48136985, val_MSE_maskV_-1.0=0.76977444, learning_rate=0.001\n", + "Epoch 137/166 - loss=0.72441864, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52337277, MSE_maskV_-1.0=0.7240324, val_loss=0.7684412, val_CC_maskV_-1.0=0.48529586, val_MSE_maskV_-1.0=0.76553541, learning_rate=0.001\n", + "Epoch 154/166 - loss=0.71888399, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52740222, MSE_maskV_-1.0=0.71901613, val_loss=0.76275647, val_CC_maskV_-1.0=0.49071315, val_MSE_maskV_-1.0=0.76015848, learning_rate=0.001\n", + "Epoch 166/166 - loss=0.71748644, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52935463, MSE_maskV_-1.0=0.71826106, val_loss=0.76142818, val_CC_maskV_-1.0=0.49168393, val_MSE_maskV_-1.0=0.75893611, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:11:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 42.63s\n", + "\u001b[32m2025-05-30 15:11:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.75948226)\n", + "\u001b[32m2025-05-30 15:11:27\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 748us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:11:28\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.716, R2_maskV_-1.0=0.285, CC_maskV_-1.0=0.533\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 778us/step\n", + "51/51 [==============================] - 0s 813us/step\n", + "84/84 [==============================] - 0s 737us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:11:28\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 1/4 method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16\" (16/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4_DPAD_RTR2_uAKCzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:11:28\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1948] \u001b[1;30mINFO\u001b[0m Saving results for fold 1 as ..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f1_4.p\n", + "\u001b[32m2025-05-30 15:11:28\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1381] \u001b[1;30mINFO\u001b[0m Fold 2/4: training samples: 8014, test samples=2672\n", + "\u001b[32m2025-05-30 15:11:28\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1754] \u001b[1;30mINFO\u001b[0m Running fold 2 (NTrain=8014, NTest=2672)\n", + "\u001b[32m2025-05-30 15:11:28\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1849] \u001b[1;30mINFO\u001b[0m Signal dimensions: y => (10686, 46), z => (10686, 4), u => None\n", + "\u001b[32m2025-05-30 15:11:28\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1856] \u001b[1;30mINFO\u001b[0m Method codes to fit: ['DPAD_RTR2_ErSV16', 'DPAD_RTR2_A1HL64U_ErSV16', 'DPAD_RTR2_K1HL64U_ErSV16', 'DPAD_RTR2_Cz1HL64U_ErSV16', 'DPAD_RTR2_Cy1HL64U_ErSV16', 'DPAD_RTR2_uAK1HL64U_ErSV16', 'DPAD_RTR2_ACz1HL64U_ErSV16', 'DPAD_RTR2_ACy1HL64U_ErSV16', 'DPAD_RTR2_KCz1HL64U_ErSV16', 'DPAD_RTR2_KCy1HL64U_ErSV16', 'DPAD_RTR2_CzCy1HL64U_ErSV16', 'DPAD_RTR2_uAKCz1HL64U_ErSV16', 'DPAD_RTR2_uAKCy1HL64U_ErSV16', 'DPAD_RTR2_ACzCy1HL64U_ErSV16', 'DPAD_RTR2_KCzCy1HL64U_ErSV16', 'DPAD_RTR2_uAKCzCy1HL64U_ErSV16']\n", + "\u001b[32m2025-05-30 15:11:28\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1857] \u001b[1;30mINFO\u001b[0m Nx values to fit: [16]\n", + "\u001b[32m2025-05-30 15:11:28\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_ErSV16\" (1/16)\n", + "\u001b[32m2025-05-30 15:11:28\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:11:28\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:11:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:11:29\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:11:29\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:11:29\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:11:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:11:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 41 (stopped at 56 epochs).\n", + "\u001b[32m2025-05-30 15:11:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/57 - loss=rnn_1step_loss=1.0020801, rnn_1step_R2_maskV_-1.0=-0.014803227, rnn_1step_CC_maskV_-1.0=0.0036337879, rnn_1step_MSE_maskV_-1.0=1.0020802, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.921691, val_rnn_1step_R2_maskV_-1.0=-0.062623337, val_rnn_1step_CC_maskV_-1.0=0.066362731, learning_rate=0.001\n", + "Epoch 7/57 - loss=rnn_1step_loss=0.93855923, rnn_1step_R2_maskV_-1.0=0.049688749, rnn_1step_CC_maskV_-1.0=0.42359984, rnn_1step_MSE_maskV_-1.0=0.93855917, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.86577171, val_rnn_1step_R2_maskV_-1.0=0.00095722079, val_rnn_1step_CC_maskV_-1.0=0.36609787, learning_rate=0.001\n", + "Epoch 13/57 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.78810573, rnn_1step_R2_maskV_-1.0=0.20130134, rnn_1step_CC_maskV_-1.0=0.4989799, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.74861413, val_rnn_1step_R2_maskV_-1.0=0.13266413, val_rnn_1step_CC_maskV_-1.0=0.44885898, learning_rate=0.001\n", + "Epoch 19/57 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.65205652, rnn_1step_R2_maskV_-1.0=0.33732384, rnn_1step_CC_maskV_-1.0=0.59259266, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.66469806, val_rnn_1step_R2_maskV_-1.0=0.22549164, val_rnn_1step_CC_maskV_-1.0=0.54660285, learning_rate=0.001\n", + "Epoch 25/57 - loss=rnn_1step_loss=0.57611376, rnn_1step_R2_maskV_-1.0=0.41449133, rnn_1step_CC_maskV_-1.0=0.65092403, rnn_1step_MSE_maskV_-1.0=0.5761137, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61129594, val_rnn_1step_R2_maskV_-1.0=0.28591758, val_rnn_1step_CC_maskV_-1.0=0.59612137, learning_rate=0.001\n", + "Epoch 31/57 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.53123844, rnn_1step_R2_maskV_-1.0=0.46020359, rnn_1step_CC_maskV_-1.0=0.68414944, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5929535, val_rnn_1step_R2_maskV_-1.0=0.30611339, val_rnn_1step_CC_maskV_-1.0=0.614914, learning_rate=0.001\n", + "Epoch 37/57 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.49331331, rnn_1step_R2_maskV_-1.0=0.49934539, rnn_1step_CC_maskV_-1.0=0.71176708, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56624216, val_rnn_1step_R2_maskV_-1.0=0.33474231, val_rnn_1step_CC_maskV_-1.0=0.63838869, learning_rate=0.001\n", + "Epoch 43/57 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4759489, rnn_1step_R2_maskV_-1.0=0.51729774, rnn_1step_CC_maskV_-1.0=0.72389281, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56053334, val_rnn_1step_R2_maskV_-1.0=0.34099114, val_rnn_1step_CC_maskV_-1.0=0.64174867, learning_rate=0.001\n", + "Epoch 49/57 - loss=rnn_1step_loss=0.46891618, rnn_1step_R2_maskV_-1.0=0.5243451, rnn_1step_CC_maskV_-1.0=0.72884977, rnn_1step_MSE_maskV_-1.0=0.46891624, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56260586, val_rnn_1step_R2_maskV_-1.0=0.33890787, val_rnn_1step_CC_maskV_-1.0=0.63990301, learning_rate=0.001\n", + "Epoch 55/57 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.46300724, rnn_1step_R2_maskV_-1.0=0.53023338, rnn_1step_CC_maskV_-1.0=0.73289639, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56211579, val_rnn_1step_R2_maskV_-1.0=0.33977041, val_rnn_1step_CC_maskV_-1.0=0.64081621, learning_rate=0.001\n", + "Epoch 57/57 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4610728, rnn_1step_R2_maskV_-1.0=0.53216529, rnn_1step_CC_maskV_-1.0=0.7342155, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56135303, val_rnn_1step_R2_maskV_-1.0=0.34075314, val_rnn_1step_CC_maskV_-1.0=0.64157194, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:11:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 6.44s\n", + "\u001b[32m2025-05-30 15:11:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:11:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 148 (stopped at 163 epochs).\n", + "\u001b[32m2025-05-30 15:11:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/164 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0005026, rnn_1_1step_R2_maskV_-1.0=-0.013234839, rnn_1_1step_CC_maskV_-1.0=0.034303647, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91946983, val_rnn_1_1step_R2_maskV_-1.0=-0.05977951, val_rnn_1_1step_CC_maskV_-1.0=0.11904071, learning_rate=0.001\n", + "Epoch 18/164 - loss=rnn_1_1step_loss=0.66425395, rnn_1_1step_R2_maskV_-1.0=0.32555091, rnn_1_1step_CC_maskV_-1.0=0.57946783, rnn_1_1step_MSE_maskV_-1.0=0.66425389, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.67861682, val_rnn_1_1step_R2_maskV_-1.0=0.21118021, val_rnn_1_1step_CC_maskV_-1.0=0.52822542, learning_rate=0.001\n", + "Epoch 35/164 - loss=rnn_1_1step_loss=0.52692223, rnn_1_1step_R2_maskV_-1.0=0.46431753, rnn_1_1step_CC_maskV_-1.0=0.68704104, rnn_1_1step_MSE_maskV_-1.0=0.52692229, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61077088, val_rnn_1_1step_R2_maskV_-1.0=0.28984231, val_rnn_1_1step_CC_maskV_-1.0=0.60247791, learning_rate=0.001\n", + "Epoch 52/164 - loss=rnn_1_1step_loss=0.46819785, rnn_1_1step_R2_maskV_-1.0=0.52486032, rnn_1_1step_CC_maskV_-1.0=0.72929454, rnn_1_1step_MSE_maskV_-1.0=0.46819791, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56324536, val_rnn_1_1step_R2_maskV_-1.0=0.33906218, val_rnn_1_1step_CC_maskV_-1.0=0.6403144, learning_rate=0.001\n", + "Epoch 69/164 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44513932, rnn_1_1step_R2_maskV_-1.0=0.54833174, rnn_1_1step_CC_maskV_-1.0=0.74478835, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54575753, val_rnn_1_1step_R2_maskV_-1.0=0.35975966, val_rnn_1_1step_CC_maskV_-1.0=0.65493989, learning_rate=0.001\n", + "Epoch 86/164 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42372024, rnn_1_1step_R2_maskV_-1.0=0.57017452, rnn_1_1step_CC_maskV_-1.0=0.75864929, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52222908, val_rnn_1_1step_R2_maskV_-1.0=0.3871761, val_rnn_1_1step_CC_maskV_-1.0=0.67443383, learning_rate=0.001\n", + "Epoch 103/164 - loss=rnn_1_1step_loss=0.41166785, rnn_1_1step_R2_maskV_-1.0=0.58238584, rnn_1_1step_CC_maskV_-1.0=0.76643384, rnn_1_1step_MSE_maskV_-1.0=0.41166788, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51262301, val_rnn_1_1step_R2_maskV_-1.0=0.39799076, val_rnn_1_1step_CC_maskV_-1.0=0.68327546, learning_rate=0.001\n", + "Epoch 120/164 - loss=rnn_1_1step_loss=0.40417945, rnn_1_1step_R2_maskV_-1.0=0.58998227, rnn_1_1step_CC_maskV_-1.0=0.77124774, rnn_1_1step_MSE_maskV_-1.0=0.40417942, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50840992, val_rnn_1_1step_R2_maskV_-1.0=0.4024381, val_rnn_1_1step_CC_maskV_-1.0=0.68776238, learning_rate=0.001\n", + "Epoch 137/164 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39964059, rnn_1_1step_R2_maskV_-1.0=0.59457767, rnn_1_1step_CC_maskV_-1.0=0.77415061, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50703675, val_rnn_1_1step_R2_maskV_-1.0=0.40376419, val_rnn_1_1step_CC_maskV_-1.0=0.68973768, learning_rate=0.001\n", + "Epoch 154/164 - loss=rnn_1_1step_loss=0.39697853, rnn_1_1step_R2_maskV_-1.0=0.59725821, rnn_1_1step_CC_maskV_-1.0=0.77585244, rnn_1_1step_MSE_maskV_-1.0=0.39697856, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50691372, val_rnn_1_1step_R2_maskV_-1.0=0.40382314, val_rnn_1_1step_CC_maskV_-1.0=0.69040781, learning_rate=0.001\n", + "Epoch 164/164 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39594194, rnn_1_1step_R2_maskV_-1.0=0.59829676, rnn_1_1step_CC_maskV_-1.0=0.7765162, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.506993, val_rnn_1_1step_R2_maskV_-1.0=0.40372518, val_rnn_1_1step_CC_maskV_-1.0=0.69055724, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:11:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.25s\n", + "\u001b[32m2025-05-30 15:11:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.50689322)\n", + "\u001b[32m2025-05-30 15:11:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.356, R2_maskV_-1.0=0.644, CC_maskV_-1.0=0.803\n", + "\u001b[32m2025-05-30 15:11:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.479, R2_maskV_-1.0=0.448, CC_maskV_-1.0=0.716\n", + "\u001b[32m2025-05-30 15:11:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:11:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:12:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 216 (stopped at 231 epochs).\n", + "\u001b[32m2025-05-30 15:12:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/232 - loss=6.5961146, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=-0.021797812, MSE_maskV_-1.0=6.5792665, val_loss=1.5550077, val_CC_maskV_-1.0=0.0047759051, val_MSE_maskV_-1.0=1.5453458, learning_rate=0.001\n", + "Epoch 25/232 - loss=0.84926748, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38947967, MSE_maskV_-1.0=0.84962732, val_loss=0.88760638, val_CC_maskV_-1.0=0.38058397, val_MSE_maskV_-1.0=0.88469344, learning_rate=0.001\n", + "Epoch 49/232 - loss=0.79341745, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45744848, MSE_maskV_-1.0=0.79339761, val_loss=0.82930863, val_CC_maskV_-1.0=0.44596109, val_MSE_maskV_-1.0=0.82673901, learning_rate=0.001\n", + "Epoch 73/232 - loss=0.76596177, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48488882, MSE_maskV_-1.0=0.76629585, val_loss=0.79711115, val_CC_maskV_-1.0=0.47902396, val_MSE_maskV_-1.0=0.79481596, learning_rate=0.001\n", + "Epoch 97/232 - loss=0.75110346, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50007069, MSE_maskV_-1.0=0.75071639, val_loss=0.78037274, val_CC_maskV_-1.0=0.49502853, val_MSE_maskV_-1.0=0.77800542, learning_rate=0.001\n", + "Epoch 121/232 - loss=0.74088353, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.508672, MSE_maskV_-1.0=0.74070805, val_loss=0.76821995, val_CC_maskV_-1.0=0.50561082, val_MSE_maskV_-1.0=0.76574647, learning_rate=0.001\n", + "Epoch 145/232 - loss=0.73400074, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5147118, MSE_maskV_-1.0=0.73446709, val_loss=0.76496965, val_CC_maskV_-1.0=0.50656772, val_MSE_maskV_-1.0=0.7626555, learning_rate=0.001\n", + "Epoch 169/232 - loss=0.7292226, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52004415, MSE_maskV_-1.0=0.72911209, val_loss=0.76093203, val_CC_maskV_-1.0=0.50962323, val_MSE_maskV_-1.0=0.75867522, learning_rate=0.001\n", + "Epoch 193/232 - loss=0.72550827, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52387536, MSE_maskV_-1.0=0.72529799, val_loss=0.75774509, val_CC_maskV_-1.0=0.5136385, val_MSE_maskV_-1.0=0.75556237, learning_rate=0.001\n", + "Epoch 217/232 - loss=0.72347122, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52427155, MSE_maskV_-1.0=0.72265095, val_loss=0.75674659, val_CC_maskV_-1.0=0.51343477, val_MSE_maskV_-1.0=0.75458097, learning_rate=0.001\n", + "Epoch 232/232 - loss=0.72164685, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52638888, MSE_maskV_-1.0=0.72133619, val_loss=0.75227296, val_CC_maskV_-1.0=0.51790977, val_MSE_maskV_-1.0=0.74977827, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:12:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 53.81s\n", + "\u001b[32m2025-05-30 15:12:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:13:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 175 (stopped at 190 epochs).\n", + "\u001b[32m2025-05-30 15:13:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/191 - loss=4.7023425, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.015798904, MSE_maskV_-1.0=4.6913848, val_loss=1.3373572, val_CC_maskV_-1.0=0.02427898, val_MSE_maskV_-1.0=1.3341522, learning_rate=0.001\n", + "Epoch 21/191 - loss=0.86112982, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37259924, MSE_maskV_-1.0=0.86105031, val_loss=0.88543916, val_CC_maskV_-1.0=0.38049829, val_MSE_maskV_-1.0=0.88291186, learning_rate=0.001\n", + "Epoch 41/191 - loss=0.80654353, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44193059, MSE_maskV_-1.0=0.80694366, val_loss=0.83981627, val_CC_maskV_-1.0=0.43325147, val_MSE_maskV_-1.0=0.83757597, learning_rate=0.001\n", + "Epoch 61/191 - loss=0.77726591, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47447315, MSE_maskV_-1.0=0.77757549, val_loss=0.8044045, val_CC_maskV_-1.0=0.47033343, val_MSE_maskV_-1.0=0.80259156, learning_rate=0.001\n", + "Epoch 81/191 - loss=0.75971133, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49199945, MSE_maskV_-1.0=0.76021695, val_loss=0.78733104, val_CC_maskV_-1.0=0.48707828, val_MSE_maskV_-1.0=0.78527331, learning_rate=0.001\n", + "Epoch 101/191 - loss=0.74763501, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50325966, MSE_maskV_-1.0=0.7469399, val_loss=0.77601159, val_CC_maskV_-1.0=0.49612471, val_MSE_maskV_-1.0=0.77410299, learning_rate=0.001\n", + "Epoch 121/191 - loss=0.74040335, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.509058, MSE_maskV_-1.0=0.74023944, val_loss=0.76562631, val_CC_maskV_-1.0=0.50726163, val_MSE_maskV_-1.0=0.76342118, learning_rate=0.001\n", + "Epoch 141/191 - loss=0.73440671, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51538205, MSE_maskV_-1.0=0.73620826, val_loss=0.76495039, val_CC_maskV_-1.0=0.50573778, val_MSE_maskV_-1.0=0.76287794, learning_rate=0.001\n", + "Epoch 161/191 - loss=0.73040593, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51916808, MSE_maskV_-1.0=0.73066777, val_loss=0.76040429, val_CC_maskV_-1.0=0.51039487, val_MSE_maskV_-1.0=0.75828201, learning_rate=0.001\n", + "Epoch 181/191 - loss=0.72814846, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52008706, MSE_maskV_-1.0=0.72805643, val_loss=0.75605518, val_CC_maskV_-1.0=0.51406968, val_MSE_maskV_-1.0=0.75385553, learning_rate=0.001\n", + "Epoch 191/191 - loss=0.72657436, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52109462, MSE_maskV_-1.0=0.727099, val_loss=0.75566161, val_CC_maskV_-1.0=0.51390129, val_MSE_maskV_-1.0=0.7535131, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:13:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 45.81s\n", + "\u001b[32m2025-05-30 15:13:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.75084472)\n", + "\u001b[32m2025-05-30 15:13:31\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 710us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:13:32\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.724, R2_maskV_-1.0=0.278, CC_maskV_-1.0=0.527\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 742us/step\n", + "51/51 [==============================] - 0s 770us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:13:32\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_ErSV16\" (1/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:13:32\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_A1HL64U_ErSV16\" (2/16)\n", + "\u001b[32m2025-05-30 15:13:32\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_A1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:13:32\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:13:32\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:13:32\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:13:32\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:13:32\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:13:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:13:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 161 (stopped at 176 epochs).\n", + "\u001b[32m2025-05-30 15:13:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/177 - loss=rnn_1step_loss=1.0013793, rnn_1step_R2_maskV_-1.0=-0.014130794, rnn_1step_CC_maskV_-1.0=0.01294158, rnn_1step_MSE_maskV_-1.0=1.0013794, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91904831, val_rnn_1step_R2_maskV_-1.0=-0.060129598, val_rnn_1step_CC_maskV_-1.0=0.14092165, learning_rate=0.001\n", + "Epoch 19/177 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.66785163, rnn_1step_R2_maskV_-1.0=0.32128543, rnn_1step_CC_maskV_-1.0=0.57788223, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.68801546, val_rnn_1step_R2_maskV_-1.0=0.19476008, val_rnn_1step_CC_maskV_-1.0=0.51690388, learning_rate=0.001\n", + "Epoch 37/177 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.54547834, rnn_1step_R2_maskV_-1.0=0.44497448, rnn_1step_CC_maskV_-1.0=0.67373991, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6245479, val_rnn_1step_R2_maskV_-1.0=0.27445975, val_rnn_1step_CC_maskV_-1.0=0.58138835, learning_rate=0.001\n", + "Epoch 55/177 - loss=rnn_1step_loss=0.49741086, rnn_1step_R2_maskV_-1.0=0.49382201, rnn_1step_CC_maskV_-1.0=0.70841658, rnn_1step_MSE_maskV_-1.0=0.49741089, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60978431, val_rnn_1step_R2_maskV_-1.0=0.29195827, val_rnn_1step_CC_maskV_-1.0=0.60138279, learning_rate=0.001\n", + "Epoch 73/177 - loss=rnn_1step_loss=0.45866546, rnn_1step_R2_maskV_-1.0=0.53343427, rnn_1step_CC_maskV_-1.0=0.73541141, rnn_1step_MSE_maskV_-1.0=0.45866543, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58729702, val_rnn_1step_R2_maskV_-1.0=0.31845453, val_rnn_1step_CC_maskV_-1.0=0.61814517, learning_rate=0.001\n", + "Epoch 91/177 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41407588, rnn_1step_R2_maskV_-1.0=0.57865989, rnn_1step_CC_maskV_-1.0=0.76546621, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56099772, val_rnn_1step_R2_maskV_-1.0=0.34737736, val_rnn_1step_CC_maskV_-1.0=0.6433205, learning_rate=0.001\n", + "Epoch 109/177 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37656271, rnn_1step_R2_maskV_-1.0=0.61711311, rnn_1step_CC_maskV_-1.0=0.79095364, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51890939, val_rnn_1step_R2_maskV_-1.0=0.39482465, val_rnn_1step_CC_maskV_-1.0=0.66812426, learning_rate=0.001\n", + "Epoch 127/177 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35618296, rnn_1step_R2_maskV_-1.0=0.6376009, rnn_1step_CC_maskV_-1.0=0.80437648, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5036, val_rnn_1step_R2_maskV_-1.0=0.41433215, val_rnn_1step_CC_maskV_-1.0=0.69230509, learning_rate=0.001\n", + "Epoch 145/177 - loss=rnn_1step_loss=0.33735493, rnn_1step_R2_maskV_-1.0=0.65661967, rnn_1step_CC_maskV_-1.0=0.81413883, rnn_1step_MSE_maskV_-1.0=0.33735496, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48581824, val_rnn_1step_R2_maskV_-1.0=0.43535826, val_rnn_1step_CC_maskV_-1.0=0.69818932, learning_rate=0.001\n", + "Epoch 163/177 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33068022, rnn_1step_R2_maskV_-1.0=0.66378981, rnn_1step_CC_maskV_-1.0=0.81900704, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47043452, val_rnn_1step_R2_maskV_-1.0=0.45426327, val_rnn_1step_CC_maskV_-1.0=0.70921719, learning_rate=0.001\n", + "Epoch 177/177 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32062742, rnn_1step_R2_maskV_-1.0=0.67376965, rnn_1step_CC_maskV_-1.0=0.82370007, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49126491, val_rnn_1step_R2_maskV_-1.0=0.42988878, val_rnn_1step_CC_maskV_-1.0=0.70064485, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:13:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 20.32s\n", + "\u001b[32m2025-05-30 15:13:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:14:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 173 (stopped at 188 epochs).\n", + "\u001b[32m2025-05-30 15:14:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/189 - loss=rnn_1_1step_loss=0.99846941, rnn_1_1step_R2_maskV_-1.0=-0.011101633, rnn_1_1step_CC_maskV_-1.0=0.073870286, rnn_1_1step_MSE_maskV_-1.0=0.99846947, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91848063, val_rnn_1_1step_R2_maskV_-1.0=-0.059412837, val_rnn_1_1step_CC_maskV_-1.0=0.1358538, learning_rate=0.001\n", + "Epoch 20/189 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.63770157, rnn_1_1step_R2_maskV_-1.0=0.35118404, rnn_1_1step_CC_maskV_-1.0=0.60324252, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.66812199, val_rnn_1_1step_R2_maskV_-1.0=0.21751279, val_rnn_1_1step_CC_maskV_-1.0=0.53713733, learning_rate=0.001\n", + "Epoch 39/189 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.53346658, rnn_1_1step_R2_maskV_-1.0=0.45658207, rnn_1_1step_CC_maskV_-1.0=0.68257642, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61952168, val_rnn_1_1step_R2_maskV_-1.0=0.27873033, val_rnn_1_1step_CC_maskV_-1.0=0.58667552, learning_rate=0.001\n", + "Epoch 58/189 - loss=rnn_1_1step_loss=0.48095164, rnn_1_1step_R2_maskV_-1.0=0.50966692, rnn_1_1step_CC_maskV_-1.0=0.72026533, rnn_1_1step_MSE_maskV_-1.0=0.48095161, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60247022, val_rnn_1_1step_R2_maskV_-1.0=0.30118436, val_rnn_1_1step_CC_maskV_-1.0=0.60689831, learning_rate=0.001\n", + "Epoch 77/189 - loss=rnn_1_1step_loss=0.43135735, rnn_1_1step_R2_maskV_-1.0=0.56022006, rnn_1_1step_CC_maskV_-1.0=0.7538805, rnn_1_1step_MSE_maskV_-1.0=0.43135732, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57009006, val_rnn_1_1step_R2_maskV_-1.0=0.33704311, val_rnn_1_1step_CC_maskV_-1.0=0.63326836, learning_rate=0.001\n", + "Epoch 96/189 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40587518, rnn_1_1step_R2_maskV_-1.0=0.58690417, rnn_1_1step_CC_maskV_-1.0=0.77322191, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55066258, val_rnn_1_1step_R2_maskV_-1.0=0.35915685, val_rnn_1_1step_CC_maskV_-1.0=0.65561342, learning_rate=0.001\n", + "Epoch 115/189 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.35776091, rnn_1_1step_R2_maskV_-1.0=0.63645208, rnn_1_1step_CC_maskV_-1.0=0.8012054, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5106886, val_rnn_1_1step_R2_maskV_-1.0=0.40594715, val_rnn_1_1step_CC_maskV_-1.0=0.67865872, learning_rate=0.001\n", + "Epoch 134/189 - loss=rnn_1_1step_loss=0.34152892, rnn_1_1step_R2_maskV_-1.0=0.65288192, rnn_1_1step_CC_maskV_-1.0=0.81064004, rnn_1_1step_MSE_maskV_-1.0=0.34152895, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50983757, val_rnn_1_1step_R2_maskV_-1.0=0.40684289, val_rnn_1_1step_CC_maskV_-1.0=0.68515307, learning_rate=0.001\n", + "Epoch 153/189 - loss=rnn_1_1step_loss=0.3314105, rnn_1_1step_R2_maskV_-1.0=0.66353524, rnn_1_1step_CC_maskV_-1.0=0.81766599, rnn_1_1step_MSE_maskV_-1.0=0.33141053, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47148362, val_rnn_1_1step_R2_maskV_-1.0=0.45055568, val_rnn_1_1step_CC_maskV_-1.0=0.70680267, learning_rate=0.001\n", + "Epoch 172/189 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33384266, rnn_1_1step_R2_maskV_-1.0=0.66036206, rnn_1_1step_CC_maskV_-1.0=0.81531793, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50998694, val_rnn_1_1step_R2_maskV_-1.0=0.40390131, val_rnn_1_1step_CC_maskV_-1.0=0.69378495, learning_rate=0.001\n", + "Epoch 189/189 - loss=rnn_1_1step_loss=0.31866875, rnn_1_1step_R2_maskV_-1.0=0.67606413, rnn_1_1step_CC_maskV_-1.0=0.8258996, rnn_1_1step_MSE_maskV_-1.0=0.31866878, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46637955, val_rnn_1_1step_R2_maskV_-1.0=0.45658922, val_rnn_1_1step_CC_maskV_-1.0=0.71116012, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:14:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 21.21s\n", + "\u001b[32m2025-05-30 15:14:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.45219526)\n", + "\u001b[32m2025-05-30 15:14:16\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.289, R2_maskV_-1.0=0.711, CC_maskV_-1.0=0.844\n", + "\u001b[32m2025-05-30 15:14:16\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.442, R2_maskV_-1.0=0.496, CC_maskV_-1.0=0.733\n", + "\u001b[32m2025-05-30 15:14:16\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:14:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:14:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 103 (stopped at 118 epochs).\n", + "\u001b[32m2025-05-30 15:14:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/119 - loss=3.0223434, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.037420738, MSE_maskV_-1.0=3.0167527, val_loss=1.3469914, val_CC_maskV_-1.0=0.091350324, val_MSE_maskV_-1.0=1.3413844, learning_rate=0.001\n", + "Epoch 13/119 - loss=0.81115162, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43541798, MSE_maskV_-1.0=0.81033355, val_loss=0.84582347, val_CC_maskV_-1.0=0.4268131, val_MSE_maskV_-1.0=0.84383041, learning_rate=0.001\n", + "Epoch 25/119 - loss=0.77416545, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47632164, MSE_maskV_-1.0=0.77452391, val_loss=0.81005841, val_CC_maskV_-1.0=0.46225354, val_MSE_maskV_-1.0=0.8093062, learning_rate=0.001\n", + "Epoch 37/119 - loss=0.75839812, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4919495, MSE_maskV_-1.0=0.75866038, val_loss=0.79091257, val_CC_maskV_-1.0=0.48106918, val_MSE_maskV_-1.0=0.79017138, learning_rate=0.001\n", + "Epoch 49/119 - loss=0.75002927, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49990609, MSE_maskV_-1.0=0.75001103, val_loss=0.78530538, val_CC_maskV_-1.0=0.4861064, val_MSE_maskV_-1.0=0.7845785, learning_rate=0.001\n", + "Epoch 61/119 - loss=0.74632901, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50354409, MSE_maskV_-1.0=0.74642593, val_loss=0.77909774, val_CC_maskV_-1.0=0.49080119, val_MSE_maskV_-1.0=0.77917784, learning_rate=0.001\n", + "Epoch 73/119 - loss=0.74353683, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50500488, MSE_maskV_-1.0=0.74388558, val_loss=0.77696377, val_CC_maskV_-1.0=0.49324539, val_MSE_maskV_-1.0=0.77644342, learning_rate=0.001\n", + "Epoch 85/119 - loss=0.74195802, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50771594, MSE_maskV_-1.0=0.7419439, val_loss=0.77747673, val_CC_maskV_-1.0=0.49250895, val_MSE_maskV_-1.0=0.77729779, learning_rate=0.001\n", + "Epoch 97/119 - loss=0.74118352, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50871974, MSE_maskV_-1.0=0.74073923, val_loss=0.77322602, val_CC_maskV_-1.0=0.49741155, val_MSE_maskV_-1.0=0.77268392, learning_rate=0.001\n", + "Epoch 109/119 - loss=0.74027324, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.509022, MSE_maskV_-1.0=0.73992938, val_loss=0.77527905, val_CC_maskV_-1.0=0.49530086, val_MSE_maskV_-1.0=0.77492911, learning_rate=0.001\n", + "Epoch 119/119 - loss=0.73971933, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50981772, MSE_maskV_-1.0=0.7409296, val_loss=0.77483809, val_CC_maskV_-1.0=0.49597725, val_MSE_maskV_-1.0=0.77440548, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:14:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 31.76s\n", + "\u001b[32m2025-05-30 15:14:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:15:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 90 (stopped at 105 epochs).\n", + "\u001b[32m2025-05-30 15:15:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/106 - loss=3.0145974, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.069343038, MSE_maskV_-1.0=3.0095117, val_loss=1.3306684, val_CC_maskV_-1.0=0.096968286, val_MSE_maskV_-1.0=1.3272859, learning_rate=0.001\n", + "Epoch 12/106 - loss=0.81926078, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42556122, MSE_maskV_-1.0=0.8197785, val_loss=0.84990156, val_CC_maskV_-1.0=0.4197062, val_MSE_maskV_-1.0=0.84854841, learning_rate=0.001\n", + "Epoch 23/106 - loss=0.77948517, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47043049, MSE_maskV_-1.0=0.77925885, val_loss=0.8092224, val_CC_maskV_-1.0=0.46399209, val_MSE_maskV_-1.0=0.80841506, learning_rate=0.001\n", + "Epoch 34/106 - loss=0.76125216, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4889816, MSE_maskV_-1.0=0.76136374, val_loss=0.79311609, val_CC_maskV_-1.0=0.47910333, val_MSE_maskV_-1.0=0.79225475, learning_rate=0.001\n", + "Epoch 45/106 - loss=0.75304037, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49726826, MSE_maskV_-1.0=0.75257182, val_loss=0.78722191, val_CC_maskV_-1.0=0.48249042, val_MSE_maskV_-1.0=0.78721595, learning_rate=0.001\n", + "Epoch 56/106 - loss=0.74766487, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50167727, MSE_maskV_-1.0=0.74785042, val_loss=0.77909213, val_CC_maskV_-1.0=0.49113095, val_MSE_maskV_-1.0=0.77887148, learning_rate=0.001\n", + "Epoch 67/106 - loss=0.74452382, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50524384, MSE_maskV_-1.0=0.74421006, val_loss=0.77617019, val_CC_maskV_-1.0=0.49369469, val_MSE_maskV_-1.0=0.77629608, learning_rate=0.001\n", + "Epoch 78/106 - loss=0.74277365, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50628018, MSE_maskV_-1.0=0.74249387, val_loss=0.77642471, val_CC_maskV_-1.0=0.49383393, val_MSE_maskV_-1.0=0.77632934, learning_rate=0.001\n", + "Epoch 89/106 - loss=0.74201524, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50739753, MSE_maskV_-1.0=0.74206132, val_loss=0.77317435, val_CC_maskV_-1.0=0.49689335, val_MSE_maskV_-1.0=0.77321547, learning_rate=0.001\n", + "Epoch 100/106 - loss=0.74093676, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50760108, MSE_maskV_-1.0=0.74084979, val_loss=0.77260518, val_CC_maskV_-1.0=0.49732065, val_MSE_maskV_-1.0=0.77270079, learning_rate=0.001\n", + "Epoch 106/106 - loss=0.74038154, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50887996, MSE_maskV_-1.0=0.74023932, val_loss=0.7745586, val_CC_maskV_-1.0=0.49495685, val_MSE_maskV_-1.0=0.77474958, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:15:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 26.38s\n", + "\u001b[32m2025-05-30 15:15:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.77110726)\n", + "\u001b[32m2025-05-30 15:15:14\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 727us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:15:14\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.74, R2_maskV_-1.0=0.26, CC_maskV_-1.0=0.51\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 736us/step\n", + "51/51 [==============================] - 0s 716us/step\n", + "84/84 [==============================] - 0s 670us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:15:15\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_A1HL64U_ErSV16\" (2/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_A1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:15:15\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_K1HL64U_ErSV16\" (3/16)\n", + "\u001b[32m2025-05-30 15:15:15\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_K1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:15:15\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:15:15\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:15:15\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:15:15\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:15:15\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:15:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:15:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 65 (stopped at 80 epochs).\n", + "\u001b[32m2025-05-30 15:15:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/81 - loss=rnn_1step_loss=1.0006157, rnn_1step_R2_maskV_-1.0=-0.013266783, rnn_1step_CC_maskV_-1.0=0.12003238, rnn_1step_MSE_maskV_-1.0=1.0006156, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92149115, val_rnn_1step_R2_maskV_-1.0=-0.062678829, val_rnn_1step_CC_maskV_-1.0=0.20435698, learning_rate=0.001\n", + "Epoch 10/81 - loss=rnn_1step_loss=0.84605902, rnn_1step_R2_maskV_-1.0=0.14120495, rnn_1step_CC_maskV_-1.0=0.4036082, rnn_1step_MSE_maskV_-1.0=0.84605896, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.79065967, val_rnn_1step_R2_maskV_-1.0=0.085136682, val_rnn_1step_CC_maskV_-1.0=0.38140437, learning_rate=0.001\n", + "Epoch 19/81 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.64469081, rnn_1step_R2_maskV_-1.0=0.34248027, rnn_1step_CC_maskV_-1.0=0.59646749, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.67216831, val_rnn_1step_R2_maskV_-1.0=0.22366554, val_rnn_1step_CC_maskV_-1.0=0.52935898, learning_rate=0.001\n", + "Epoch 28/81 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.53033668, rnn_1step_R2_maskV_-1.0=0.45988846, rnn_1step_CC_maskV_-1.0=0.68565267, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58721823, val_rnn_1step_R2_maskV_-1.0=0.31896082, val_rnn_1step_CC_maskV_-1.0=0.61111587, learning_rate=0.001\n", + "Epoch 37/81 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42144081, rnn_1step_R2_maskV_-1.0=0.57169068, rnn_1step_CC_maskV_-1.0=0.76074249, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52868551, val_rnn_1step_R2_maskV_-1.0=0.38431218, val_rnn_1step_CC_maskV_-1.0=0.66374236, learning_rate=0.001\n", + "Epoch 46/81 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37089983, rnn_1step_R2_maskV_-1.0=0.62351269, rnn_1step_CC_maskV_-1.0=0.79330635, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49958706, val_rnn_1step_R2_maskV_-1.0=0.41634306, val_rnn_1step_CC_maskV_-1.0=0.68831235, learning_rate=0.001\n", + "Epoch 55/81 - loss=rnn_1step_loss=0.33228734, rnn_1step_R2_maskV_-1.0=0.66296434, rnn_1step_CC_maskV_-1.0=0.81721139, rnn_1step_MSE_maskV_-1.0=0.33228737, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48134542, val_rnn_1step_R2_maskV_-1.0=0.43689597, val_rnn_1step_CC_maskV_-1.0=0.70468765, learning_rate=0.001\n", + "Epoch 64/81 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.2966249, rnn_1step_R2_maskV_-1.0=0.69942009, rnn_1step_CC_maskV_-1.0=0.83861178, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46855775, val_rnn_1step_R2_maskV_-1.0=0.45087969, val_rnn_1step_CC_maskV_-1.0=0.71842527, learning_rate=0.001\n", + "Epoch 73/81 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27236816, rnn_1step_R2_maskV_-1.0=0.72417772, rnn_1step_CC_maskV_-1.0=0.85284126, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47311714, val_rnn_1step_R2_maskV_-1.0=0.44491741, val_rnn_1step_CC_maskV_-1.0=0.72054744, learning_rate=0.001\n", + "Epoch 81/81 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.25862315, rnn_1step_R2_maskV_-1.0=0.73814321, rnn_1step_CC_maskV_-1.0=0.86075884, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48000208, val_rnn_1step_R2_maskV_-1.0=0.43661213, val_rnn_1step_CC_maskV_-1.0=0.71945649, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:15:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 9.76s\n", + "\u001b[32m2025-05-30 15:15:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:15:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 76 (stopped at 91 epochs).\n", + "\u001b[32m2025-05-30 15:15:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/92 - loss=rnn_1_1step_loss=1.0007967, rnn_1_1step_R2_maskV_-1.0=-0.013437033, rnn_1_1step_CC_maskV_-1.0=0.11497106, rnn_1_1step_MSE_maskV_-1.0=1.0007966, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92223531, val_rnn_1_1step_R2_maskV_-1.0=-0.063657388, val_rnn_1_1step_CC_maskV_-1.0=0.21391106, learning_rate=0.001\n", + "Epoch 11/92 - loss=rnn_1_1step_loss=0.8103444, rnn_1_1step_R2_maskV_-1.0=0.17887533, rnn_1_1step_CC_maskV_-1.0=0.51370519, rnn_1_1step_MSE_maskV_-1.0=0.81034434, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.73980647, val_rnn_1_1step_R2_maskV_-1.0=0.14216875, val_rnn_1_1step_CC_maskV_-1.0=0.47511977, learning_rate=0.001\n", + "Epoch 21/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.56125289, rnn_1_1step_R2_maskV_-1.0=0.42918658, rnn_1_1step_CC_maskV_-1.0=0.66241431, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61002702, val_rnn_1_1step_R2_maskV_-1.0=0.28916001, val_rnn_1_1step_CC_maskV_-1.0=0.5992685, learning_rate=0.001\n", + "Epoch 31/92 - loss=rnn_1_1step_loss=0.44231203, rnn_1_1step_R2_maskV_-1.0=0.55096895, rnn_1_1step_CC_maskV_-1.0=0.7463575, rnn_1_1step_MSE_maskV_-1.0=0.44231206, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53664249, val_rnn_1_1step_R2_maskV_-1.0=0.37303478, val_rnn_1_1step_CC_maskV_-1.0=0.66752034, learning_rate=0.001\n", + "Epoch 41/92 - loss=rnn_1_1step_loss=0.37603354, rnn_1_1step_R2_maskV_-1.0=0.61931312, rnn_1_1step_CC_maskV_-1.0=0.78993368, rnn_1_1step_MSE_maskV_-1.0=0.37603357, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50513911, val_rnn_1_1step_R2_maskV_-1.0=0.40729901, val_rnn_1_1step_CC_maskV_-1.0=0.68945062, learning_rate=0.001\n", + "Epoch 51/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32784408, rnn_1_1step_R2_maskV_-1.0=0.66861427, rnn_1_1step_CC_maskV_-1.0=0.82001221, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48226896, val_rnn_1_1step_R2_maskV_-1.0=0.43420464, val_rnn_1_1step_CC_maskV_-1.0=0.70695394, learning_rate=0.001\n", + "Epoch 61/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.29040739, rnn_1_1step_R2_maskV_-1.0=0.70683098, rnn_1_1step_CC_maskV_-1.0=0.84227526, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46535218, val_rnn_1_1step_R2_maskV_-1.0=0.45381045, val_rnn_1_1step_CC_maskV_-1.0=0.72227627, learning_rate=0.001\n", + "Epoch 71/92 - loss=rnn_1_1step_loss=0.27091596, rnn_1_1step_R2_maskV_-1.0=0.72632897, rnn_1_1step_CC_maskV_-1.0=0.85359836, rnn_1_1step_MSE_maskV_-1.0=0.27091599, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45960733, val_rnn_1_1step_R2_maskV_-1.0=0.46036381, val_rnn_1_1step_CC_maskV_-1.0=0.7281673, learning_rate=0.001\n", + "Epoch 81/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.25486302, rnn_1_1step_R2_maskV_-1.0=0.74243188, rnn_1_1step_CC_maskV_-1.0=0.86317158, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46954814, val_rnn_1_1step_R2_maskV_-1.0=0.44914705, val_rnn_1_1step_CC_maskV_-1.0=0.72548985, learning_rate=0.001\n", + "Epoch 91/92 - loss=rnn_1_1step_loss=0.24608541, rnn_1_1step_R2_maskV_-1.0=0.75125861, rnn_1_1step_CC_maskV_-1.0=0.86800736, rnn_1_1step_MSE_maskV_-1.0=0.24608539, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48159862, val_rnn_1_1step_R2_maskV_-1.0=0.4350608, val_rnn_1_1step_CC_maskV_-1.0=0.72318864, learning_rate=0.001\n", + "Epoch 92/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.24856925, rnn_1_1step_R2_maskV_-1.0=0.74841249, rnn_1_1step_CC_maskV_-1.0=0.86677164, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47890842, val_rnn_1_1step_R2_maskV_-1.0=0.43829072, val_rnn_1_1step_CC_maskV_-1.0=0.72386032, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:15:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 11.22s\n", + "\u001b[32m2025-05-30 15:15:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.45629081)\n", + "\u001b[32m2025-05-30 15:15:38\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.227, R2_maskV_-1.0=0.773, CC_maskV_-1.0=0.879\n", + "\u001b[32m2025-05-30 15:15:38\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.426, R2_maskV_-1.0=0.51, CC_maskV_-1.0=0.751\n", + "\u001b[32m2025-05-30 15:15:38\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:15:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:16:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 231 (stopped at 246 epochs).\n", + "\u001b[32m2025-05-30 15:16:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/247 - loss=2.0134392, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.03827614, MSE_maskV_-1.0=2.010705, val_loss=1.1117179, val_CC_maskV_-1.0=0.075532064, val_MSE_maskV_-1.0=1.1093162, learning_rate=0.001\n", + "Epoch 26/247 - loss=0.91347444, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.29884472, MSE_maskV_-1.0=0.91366518, val_loss=0.95050585, val_CC_maskV_-1.0=0.29381382, val_MSE_maskV_-1.0=0.94823307, learning_rate=0.001\n", + "Epoch 51/247 - loss=0.88494509, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34601676, MSE_maskV_-1.0=0.8843981, val_loss=0.92106026, val_CC_maskV_-1.0=0.34467173, val_MSE_maskV_-1.0=0.91834515, learning_rate=0.001\n", + "Epoch 76/247 - loss=0.86752665, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37167048, MSE_maskV_-1.0=0.86716008, val_loss=0.90420204, val_CC_maskV_-1.0=0.36711478, val_MSE_maskV_-1.0=0.90140295, learning_rate=0.001\n", + "Epoch 101/247 - loss=0.85587871, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38660315, MSE_maskV_-1.0=0.8550384, val_loss=0.89433396, val_CC_maskV_-1.0=0.38063458, val_MSE_maskV_-1.0=0.89056844, learning_rate=0.001\n", + "Epoch 126/247 - loss=0.84727055, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39696279, MSE_maskV_-1.0=0.84701097, val_loss=0.88284767, val_CC_maskV_-1.0=0.3960363, val_MSE_maskV_-1.0=0.87926912, learning_rate=0.001\n", + "Epoch 151/247 - loss=0.84095466, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40443838, MSE_maskV_-1.0=0.84096867, val_loss=0.87862837, val_CC_maskV_-1.0=0.40065354, val_MSE_maskV_-1.0=0.87511092, learning_rate=0.001\n", + "Epoch 176/247 - loss=0.83603895, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40980923, MSE_maskV_-1.0=0.83519918, val_loss=0.87214911, val_CC_maskV_-1.0=0.40756428, val_MSE_maskV_-1.0=0.8684414, learning_rate=0.001\n", + "Epoch 201/247 - loss=0.83144397, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41546756, MSE_maskV_-1.0=0.83107883, val_loss=0.87018019, val_CC_maskV_-1.0=0.40748855, val_MSE_maskV_-1.0=0.86669737, learning_rate=0.001\n", + "Epoch 226/247 - loss=0.82788068, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41864815, MSE_maskV_-1.0=0.82757783, val_loss=0.86708665, val_CC_maskV_-1.0=0.41112623, val_MSE_maskV_-1.0=0.86326927, learning_rate=0.001\n", + "Epoch 247/247 - loss=0.82514518, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42173418, MSE_maskV_-1.0=0.82448947, val_loss=0.86301792, val_CC_maskV_-1.0=0.41780147, val_MSE_maskV_-1.0=0.85928547, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:16:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 59.18s\n", + "\u001b[32m2025-05-30 15:16:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:17:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 231 (stopped at 246 epochs).\n", + "\u001b[32m2025-05-30 15:17:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/247 - loss=1.8400133, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.036776043, MSE_maskV_-1.0=1.8379307, val_loss=1.1096587, val_CC_maskV_-1.0=0.085533887, val_MSE_maskV_-1.0=1.105768, learning_rate=0.001\n", + "Epoch 26/247 - loss=0.91022253, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.30463073, MSE_maskV_-1.0=0.91045928, val_loss=0.94834352, val_CC_maskV_-1.0=0.30134994, val_MSE_maskV_-1.0=0.94514376, learning_rate=0.001\n", + "Epoch 51/247 - loss=0.88274509, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34945899, MSE_maskV_-1.0=0.88220364, val_loss=0.91977698, val_CC_maskV_-1.0=0.34862182, val_MSE_maskV_-1.0=0.91639233, learning_rate=0.001\n", + "Epoch 76/247 - loss=0.8659389, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37390095, MSE_maskV_-1.0=0.86556542, val_loss=0.90356463, val_CC_maskV_-1.0=0.36903423, val_MSE_maskV_-1.0=0.90022796, learning_rate=0.001\n", + "Epoch 101/247 - loss=0.85468328, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38817692, MSE_maskV_-1.0=0.85385334, val_loss=0.89380205, val_CC_maskV_-1.0=0.38196963, val_MSE_maskV_-1.0=0.8896541, learning_rate=0.001\n", + "Epoch 126/247 - loss=0.84635347, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39811328, MSE_maskV_-1.0=0.84609187, val_loss=0.88275385, val_CC_maskV_-1.0=0.39648017, val_MSE_maskV_-1.0=0.87885338, learning_rate=0.001\n", + "Epoch 151/247 - loss=0.84025472, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40533227, MSE_maskV_-1.0=0.84021217, val_loss=0.87858933, val_CC_maskV_-1.0=0.40085399, val_MSE_maskV_-1.0=0.87486559, learning_rate=0.001\n", + "Epoch 176/247 - loss=0.83548015, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41050136, MSE_maskV_-1.0=0.83463275, val_loss=0.87225503, val_CC_maskV_-1.0=0.40747309, val_MSE_maskV_-1.0=0.86838788, learning_rate=0.001\n", + "Epoch 201/247 - loss=0.83100772, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41596088, MSE_maskV_-1.0=0.83063543, val_loss=0.87029833, val_CC_maskV_-1.0=0.40737221, val_MSE_maskV_-1.0=0.86670125, learning_rate=0.001\n", + "Epoch 226/247 - loss=0.82752889, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41903952, MSE_maskV_-1.0=0.82721537, val_loss=0.86724073, val_CC_maskV_-1.0=0.410916, val_MSE_maskV_-1.0=0.86334848, learning_rate=0.001\n", + "Epoch 247/247 - loss=0.82484376, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42205244, MSE_maskV_-1.0=0.82419592, val_loss=0.86331564, val_CC_maskV_-1.0=0.4173471, val_MSE_maskV_-1.0=0.85951537, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:17:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 58.70s\n", + "\u001b[32m2025-05-30 15:17:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.86280388)\n", + "\u001b[32m2025-05-30 15:17:36\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 694us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:17:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.826, R2_maskV_-1.0=0.173, CC_maskV_-1.0=0.421\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 752us/step\n", + "51/51 [==============================] - 0s 710us/step\n", + "84/84 [==============================] - 0s 679us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:17:37\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_K1HL64U_ErSV16\" (3/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_K1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:17:37\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_Cz1HL64U_ErSV16\" (4/16)\n", + "\u001b[32m2025-05-30 15:17:37\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_Cz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:17:37\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:17:37\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:17:37\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:17:37\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:17:37\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:17:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:18:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 216 (stopped at 231 epochs).\n", + "\u001b[32m2025-05-30 15:18:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/232 - loss=rnn_1step_loss=1.0010282, rnn_1step_R2_maskV_-1.0=-0.01367835, rnn_1step_CC_maskV_-1.0=0.07231123, rnn_1step_MSE_maskV_-1.0=1.0010283, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92121911, val_rnn_1step_R2_maskV_-1.0=-0.062240034, val_rnn_1step_CC_maskV_-1.0=0.26992729, learning_rate=0.001\n", + "Epoch 25/232 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.6017285, rnn_1step_R2_maskV_-1.0=0.38721198, rnn_1step_CC_maskV_-1.0=0.63194048, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62600094, val_rnn_1step_R2_maskV_-1.0=0.27407426, val_rnn_1step_CC_maskV_-1.0=0.57247043, learning_rate=0.001\n", + "Epoch 49/232 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42199501, rnn_1step_R2_maskV_-1.0=0.57032347, rnn_1step_CC_maskV_-1.0=0.76003909, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54340333, val_rnn_1step_R2_maskV_-1.0=0.36612815, val_rnn_1step_CC_maskV_-1.0=0.65548354, learning_rate=0.001\n", + "Epoch 73/232 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37478706, rnn_1step_R2_maskV_-1.0=0.61868411, rnn_1step_CC_maskV_-1.0=0.79052305, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51261216, val_rnn_1step_R2_maskV_-1.0=0.3989889, val_rnn_1step_CC_maskV_-1.0=0.68465984, learning_rate=0.001\n", + "Epoch 97/232 - loss=rnn_1step_loss=0.34613678, rnn_1step_R2_maskV_-1.0=0.64792579, rnn_1step_CC_maskV_-1.0=0.80842555, rnn_1step_MSE_maskV_-1.0=0.34613675, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48951527, val_rnn_1step_R2_maskV_-1.0=0.42535359, val_rnn_1step_CC_maskV_-1.0=0.70453721, learning_rate=0.001\n", + "Epoch 121/232 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33145535, rnn_1step_R2_maskV_-1.0=0.66285241, rnn_1step_CC_maskV_-1.0=0.81747001, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47612906, val_rnn_1step_R2_maskV_-1.0=0.44129753, val_rnn_1step_CC_maskV_-1.0=0.71526963, learning_rate=0.001\n", + "Epoch 145/232 - loss=rnn_1step_loss=0.32441691, rnn_1step_R2_maskV_-1.0=0.67002738, rnn_1step_CC_maskV_-1.0=0.82178891, rnn_1step_MSE_maskV_-1.0=0.32441688, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47397682, val_rnn_1step_R2_maskV_-1.0=0.44395354, val_rnn_1step_CC_maskV_-1.0=0.71782374, learning_rate=0.001\n", + "Epoch 169/232 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31811345, rnn_1step_R2_maskV_-1.0=0.6764316, rnn_1step_CC_maskV_-1.0=0.82551938, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47177815, val_rnn_1step_R2_maskV_-1.0=0.44732699, val_rnn_1step_CC_maskV_-1.0=0.72026265, learning_rate=0.001\n", + "Epoch 193/232 - loss=rnn_1step_loss=0.31476834, rnn_1step_R2_maskV_-1.0=0.67992747, rnn_1step_CC_maskV_-1.0=0.82748383, rnn_1step_MSE_maskV_-1.0=0.31476837, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47347435, val_rnn_1step_R2_maskV_-1.0=0.44510591, val_rnn_1step_CC_maskV_-1.0=0.72055972, learning_rate=0.001\n", + "Epoch 217/232 - loss=rnn_1step_loss=0.31024465, rnn_1step_R2_maskV_-1.0=0.68454576, rnn_1step_CC_maskV_-1.0=0.83067274, rnn_1step_MSE_maskV_-1.0=0.31024468, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47101107, val_rnn_1step_R2_maskV_-1.0=0.44809365, val_rnn_1step_CC_maskV_-1.0=0.72134334, learning_rate=0.001\n", + "Epoch 232/232 - loss=rnn_1step_loss=0.31016657, rnn_1step_R2_maskV_-1.0=0.68431437, rnn_1step_CC_maskV_-1.0=0.83044732, rnn_1step_MSE_maskV_-1.0=0.3101666, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47709537, val_rnn_1step_R2_maskV_-1.0=0.44105753, val_rnn_1step_CC_maskV_-1.0=0.71928304, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:18:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 22.98s\n", + "\u001b[32m2025-05-30 15:18:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:18:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 250 (stopped at 265 epochs).\n", + "\u001b[32m2025-05-30 15:18:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/266 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0009881, rnn_1_1step_R2_maskV_-1.0=-0.013636105, rnn_1_1step_CC_maskV_-1.0=0.083134159, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92171335, val_rnn_1_1step_R2_maskV_-1.0=-0.062907502, val_rnn_1_1step_CC_maskV_-1.0=0.28679436, learning_rate=0.001\n", + "Epoch 28/266 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.53246087, rnn_1_1step_R2_maskV_-1.0=0.45824397, rnn_1_1step_CC_maskV_-1.0=0.68269461, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61909539, val_rnn_1_1step_R2_maskV_-1.0=0.28501624, val_rnn_1_1step_CC_maskV_-1.0=0.59603626, learning_rate=0.001\n", + "Epoch 55/266 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41892406, rnn_1_1step_R2_maskV_-1.0=0.57367945, rnn_1_1step_CC_maskV_-1.0=0.76227695, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5300377, val_rnn_1_1step_R2_maskV_-1.0=0.38069981, val_rnn_1_1step_CC_maskV_-1.0=0.6658473, learning_rate=0.001\n", + "Epoch 82/266 - loss=rnn_1_1step_loss=0.37107715, rnn_1_1step_R2_maskV_-1.0=0.62225527, rnn_1_1step_CC_maskV_-1.0=0.7931788, rnn_1_1step_MSE_maskV_-1.0=0.37107712, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50172013, val_rnn_1_1step_R2_maskV_-1.0=0.41348299, val_rnn_1_1step_CC_maskV_-1.0=0.68829817, learning_rate=0.001\n", + "Epoch 109/266 - loss=rnn_1_1step_loss=0.33827171, rnn_1_1step_R2_maskV_-1.0=0.65610015, rnn_1_1step_CC_maskV_-1.0=0.81332028, rnn_1_1step_MSE_maskV_-1.0=0.33827168, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47239017, val_rnn_1_1step_R2_maskV_-1.0=0.44601065, val_rnn_1_1step_CC_maskV_-1.0=0.71498001, learning_rate=0.001\n", + "Epoch 136/266 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32519266, rnn_1_1step_R2_maskV_-1.0=0.66937965, rnn_1_1step_CC_maskV_-1.0=0.82129824, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46576366, val_rnn_1_1step_R2_maskV_-1.0=0.45327693, val_rnn_1_1step_CC_maskV_-1.0=0.72228283, learning_rate=0.001\n", + "Epoch 163/266 - loss=rnn_1_1step_loss=0.31797394, rnn_1_1step_R2_maskV_-1.0=0.67674237, rnn_1_1step_CC_maskV_-1.0=0.82565796, rnn_1_1step_MSE_maskV_-1.0=0.31797391, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46253529, val_rnn_1_1step_R2_maskV_-1.0=0.45709142, val_rnn_1_1step_CC_maskV_-1.0=0.72553229, learning_rate=0.001\n", + "Epoch 190/266 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31262514, rnn_1_1step_R2_maskV_-1.0=0.68220007, rnn_1_1step_CC_maskV_-1.0=0.82883799, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46098158, val_rnn_1_1step_R2_maskV_-1.0=0.45912623, val_rnn_1_1step_CC_maskV_-1.0=0.72726148, learning_rate=0.001\n", + "Epoch 217/266 - loss=rnn_1_1step_loss=0.30678543, rnn_1_1step_R2_maskV_-1.0=0.68815154, rnn_1_1step_CC_maskV_-1.0=0.83236885, rnn_1_1step_MSE_maskV_-1.0=0.30678546, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46384382, val_rnn_1_1step_R2_maskV_-1.0=0.45636454, val_rnn_1_1step_CC_maskV_-1.0=0.72690612, learning_rate=0.001\n", + "Epoch 244/266 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30362311, rnn_1_1step_R2_maskV_-1.0=0.69135493, rnn_1_1step_CC_maskV_-1.0=0.8343237, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46174726, val_rnn_1_1step_R2_maskV_-1.0=0.45916307, val_rnn_1_1step_CC_maskV_-1.0=0.72756952, learning_rate=0.001\n", + "Epoch 266/266 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.29984382, rnn_1_1step_R2_maskV_-1.0=0.69527, rnn_1_1step_CC_maskV_-1.0=0.83660513, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46455765, val_rnn_1_1step_R2_maskV_-1.0=0.45618567, val_rnn_1_1step_CC_maskV_-1.0=0.72813088, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:18:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 25.89s\n", + "\u001b[32m2025-05-30 15:18:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.45808971)\n", + "\u001b[32m2025-05-30 15:18:27\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.276, R2_maskV_-1.0=0.724, CC_maskV_-1.0=0.851\n", + "\u001b[32m2025-05-30 15:18:27\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.423, R2_maskV_-1.0=0.514, CC_maskV_-1.0=0.759\n", + "\u001b[32m2025-05-30 15:18:27\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:18:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:19:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 198 (stopped at 213 epochs).\n", + "\u001b[32m2025-05-30 15:19:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/214 - loss=9.860527, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0066466955, MSE_maskV_-1.0=9.8345232, val_loss=2.1865094, val_CC_maskV_-1.0=0.037172981, val_MSE_maskV_-1.0=2.1807084, learning_rate=0.001\n", + "Epoch 23/214 - loss=0.82136422, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42375985, MSE_maskV_-1.0=0.82122862, val_loss=0.85600841, val_CC_maskV_-1.0=0.42083383, val_MSE_maskV_-1.0=0.85373342, learning_rate=0.001\n", + "Epoch 45/214 - loss=0.76580858, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48473603, MSE_maskV_-1.0=0.76531613, val_loss=0.80393529, val_CC_maskV_-1.0=0.47470152, val_MSE_maskV_-1.0=0.80158597, learning_rate=0.001\n", + "Epoch 67/214 - loss=0.74558157, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50438601, MSE_maskV_-1.0=0.74523038, val_loss=0.78430063, val_CC_maskV_-1.0=0.49390832, val_MSE_maskV_-1.0=0.78192544, learning_rate=0.001\n", + "Epoch 89/214 - loss=0.73567837, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51371628, MSE_maskV_-1.0=0.73589003, val_loss=0.77469599, val_CC_maskV_-1.0=0.50331122, val_MSE_maskV_-1.0=0.77237684, learning_rate=0.001\n", + "Epoch 111/214 - loss=0.72794038, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5220145, MSE_maskV_-1.0=0.7276054, val_loss=0.76297927, val_CC_maskV_-1.0=0.51437145, val_MSE_maskV_-1.0=0.76075131, learning_rate=0.001\n", + "Epoch 133/214 - loss=0.72190148, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52718347, MSE_maskV_-1.0=0.72132087, val_loss=0.75852317, val_CC_maskV_-1.0=0.51830101, val_MSE_maskV_-1.0=0.75628257, learning_rate=0.001\n", + "Epoch 155/214 - loss=0.71737427, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53118944, MSE_maskV_-1.0=0.71784341, val_loss=0.75702691, val_CC_maskV_-1.0=0.52065253, val_MSE_maskV_-1.0=0.75482619, learning_rate=0.001\n", + "Epoch 177/214 - loss=0.71544355, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53322053, MSE_maskV_-1.0=0.71483022, val_loss=0.75481468, val_CC_maskV_-1.0=0.52069503, val_MSE_maskV_-1.0=0.75252676, learning_rate=0.001\n", + "Epoch 199/214 - loss=0.71258378, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53593934, MSE_maskV_-1.0=0.71235567, val_loss=0.75281525, val_CC_maskV_-1.0=0.52372938, val_MSE_maskV_-1.0=0.75059068, learning_rate=0.001\n", + "Epoch 214/214 - loss=0.71248269, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53598058, MSE_maskV_-1.0=0.7121135, val_loss=0.74628884, val_CC_maskV_-1.0=0.52986711, val_MSE_maskV_-1.0=0.7441476, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:19:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 50.73s\n", + "\u001b[32m2025-05-30 15:19:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:20:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 198 (stopped at 213 epochs).\n", + "\u001b[32m2025-05-30 15:20:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/214 - loss=13.507094, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.02679177, MSE_maskV_-1.0=13.469286, val_loss=2.1352429, val_CC_maskV_-1.0=0.082715832, val_MSE_maskV_-1.0=2.1236866, learning_rate=0.001\n", + "Epoch 23/214 - loss=0.81977975, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42540833, MSE_maskV_-1.0=0.81962055, val_loss=0.85584044, val_CC_maskV_-1.0=0.41916698, val_MSE_maskV_-1.0=0.85430169, learning_rate=0.001\n", + "Epoch 45/214 - loss=0.7635805, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48690587, MSE_maskV_-1.0=0.76309043, val_loss=0.80298489, val_CC_maskV_-1.0=0.4758645, val_MSE_maskV_-1.0=0.80061918, learning_rate=0.001\n", + "Epoch 67/214 - loss=0.74375737, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5061661, MSE_maskV_-1.0=0.74342185, val_loss=0.78385764, val_CC_maskV_-1.0=0.49474403, val_MSE_maskV_-1.0=0.7813099, learning_rate=0.001\n", + "Epoch 89/214 - loss=0.73430014, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51501459, MSE_maskV_-1.0=0.73449439, val_loss=0.77459246, val_CC_maskV_-1.0=0.50368005, val_MSE_maskV_-1.0=0.77213347, learning_rate=0.001\n", + "Epoch 111/214 - loss=0.72701627, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52286303, MSE_maskV_-1.0=0.72668701, val_loss=0.76335233, val_CC_maskV_-1.0=0.51442069, val_MSE_maskV_-1.0=0.76096112, learning_rate=0.001\n", + "Epoch 133/214 - loss=0.72121054, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52779162, MSE_maskV_-1.0=0.72064477, val_loss=0.75889188, val_CC_maskV_-1.0=0.518282, val_MSE_maskV_-1.0=0.7565043, learning_rate=0.001\n", + "Epoch 155/214 - loss=0.71685052, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53167897, MSE_maskV_-1.0=0.71730596, val_loss=0.75751823, val_CC_maskV_-1.0=0.52053213, val_MSE_maskV_-1.0=0.75517547, learning_rate=0.001\n", + "Epoch 177/214 - loss=0.71508533, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53349203, MSE_maskV_-1.0=0.71447533, val_loss=0.7552129, val_CC_maskV_-1.0=0.52065992, val_MSE_maskV_-1.0=0.75280476, learning_rate=0.001\n", + "Epoch 199/214 - loss=0.71232694, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53620058, MSE_maskV_-1.0=0.71209133, val_loss=0.75343531, val_CC_maskV_-1.0=0.52342331, val_MSE_maskV_-1.0=0.7511093, learning_rate=0.001\n", + "Epoch 214/214 - loss=0.71223861, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53621691, MSE_maskV_-1.0=0.71186942, val_loss=0.74672747, val_CC_maskV_-1.0=0.52970368, val_MSE_maskV_-1.0=0.7444908, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:20:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 51.29s\n", + "\u001b[32m2025-05-30 15:20:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.74520767)\n", + "\u001b[32m2025-05-30 15:20:09\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 688us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:20:10\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.708, R2_maskV_-1.0=0.292, CC_maskV_-1.0=0.541\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 701us/step\n", + "51/51 [==============================] - 0s 749us/step\n", + "84/84 [==============================] - 0s 646us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:20:10\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_Cz1HL64U_ErSV16\" (4/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_Cz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:20:10\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_Cy1HL64U_ErSV16\" (5/16)\n", + "\u001b[32m2025-05-30 15:20:10\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_Cy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:20:10\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:20:10\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:20:10\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:20:10\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:20:10\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:20:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:20:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 157 (stopped at 172 epochs).\n", + "\u001b[32m2025-05-30 15:20:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/173 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.99798888, rnn_1step_R2_maskV_-1.0=-0.010765944, rnn_1step_CC_maskV_-1.0=0.081657581, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91808552, val_rnn_1step_R2_maskV_-1.0=-0.057843313, val_rnn_1step_CC_maskV_-1.0=0.13946673, learning_rate=0.001\n", + "Epoch 19/173 - loss=rnn_1step_loss=0.65147138, rnn_1step_R2_maskV_-1.0=0.33801961, rnn_1step_CC_maskV_-1.0=0.59172666, rnn_1step_MSE_maskV_-1.0=0.65147144, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.67400932, val_rnn_1step_R2_maskV_-1.0=0.21524678, val_rnn_1step_CC_maskV_-1.0=0.53605521, learning_rate=0.001\n", + "Epoch 37/173 - loss=rnn_1step_loss=0.52337068, rnn_1step_R2_maskV_-1.0=0.46829396, rnn_1step_CC_maskV_-1.0=0.69010019, rnn_1step_MSE_maskV_-1.0=0.52337062, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62030441, val_rnn_1step_R2_maskV_-1.0=0.28098178, val_rnn_1step_CC_maskV_-1.0=0.59010774, learning_rate=0.001\n", + "Epoch 55/173 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.47517851, rnn_1step_R2_maskV_-1.0=0.51751173, rnn_1step_CC_maskV_-1.0=0.72476965, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58174354, val_rnn_1step_R2_maskV_-1.0=0.32021716, val_rnn_1step_CC_maskV_-1.0=0.62388992, learning_rate=0.001\n", + "Epoch 73/173 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.44633827, rnn_1step_R2_maskV_-1.0=0.54700506, rnn_1step_CC_maskV_-1.0=0.74413991, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54947948, val_rnn_1step_R2_maskV_-1.0=0.35595381, val_rnn_1step_CC_maskV_-1.0=0.65038651, learning_rate=0.001\n", + "Epoch 91/173 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42309746, rnn_1step_R2_maskV_-1.0=0.57069576, rnn_1step_CC_maskV_-1.0=0.75912344, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52353966, val_rnn_1step_R2_maskV_-1.0=0.38556302, val_rnn_1step_CC_maskV_-1.0=0.67307425, learning_rate=0.001\n", + "Epoch 109/173 - loss=rnn_1step_loss=0.40891281, rnn_1step_R2_maskV_-1.0=0.5851444, rnn_1step_CC_maskV_-1.0=0.76825815, rnn_1step_MSE_maskV_-1.0=0.40891284, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51028222, val_rnn_1step_R2_maskV_-1.0=0.4004674, val_rnn_1step_CC_maskV_-1.0=0.68446487, learning_rate=0.001\n", + "Epoch 127/173 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40119788, rnn_1step_R2_maskV_-1.0=0.59296834, rnn_1step_CC_maskV_-1.0=0.77322483, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50571769, val_rnn_1step_R2_maskV_-1.0=0.40545589, val_rnn_1step_CC_maskV_-1.0=0.6888029, learning_rate=0.001\n", + "Epoch 145/173 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39659369, rnn_1step_R2_maskV_-1.0=0.59760505, rnn_1step_CC_maskV_-1.0=0.77616137, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50427312, val_rnn_1step_R2_maskV_-1.0=0.40705121, val_rnn_1step_CC_maskV_-1.0=0.69081295, learning_rate=0.001\n", + "Epoch 163/173 - loss=rnn_1step_loss=0.39386633, rnn_1step_R2_maskV_-1.0=0.60032499, rnn_1step_CC_maskV_-1.0=0.77788872, rnn_1step_MSE_maskV_-1.0=0.3938663, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50412917, val_rnn_1step_R2_maskV_-1.0=0.40728348, val_rnn_1step_CC_maskV_-1.0=0.69172668, learning_rate=0.001\n", + "Epoch 173/173 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39284381, rnn_1step_R2_maskV_-1.0=0.60133612, rnn_1step_CC_maskV_-1.0=0.77853471, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50425905, val_rnn_1step_R2_maskV_-1.0=0.40718651, val_rnn_1step_CC_maskV_-1.0=0.69200373, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:20:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.82s\n", + "\u001b[32m2025-05-30 15:20:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:21:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 402 (stopped at 417 epochs).\n", + "\u001b[32m2025-05-30 15:21:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/418 - loss=rnn_1_1step_loss=0.99814272, rnn_1_1step_R2_maskV_-1.0=-0.010749251, rnn_1_1step_CC_maskV_-1.0=0.080059968, rnn_1_1step_MSE_maskV_-1.0=0.99814266, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91710979, val_rnn_1_1step_R2_maskV_-1.0=-0.057580188, val_rnn_1_1step_CC_maskV_-1.0=0.16415425, learning_rate=0.001\n", + "Epoch 43/418 - loss=rnn_1_1step_loss=0.51329929, rnn_1_1step_R2_maskV_-1.0=0.47760251, rnn_1_1step_CC_maskV_-1.0=0.69750136, rnn_1_1step_MSE_maskV_-1.0=0.51329935, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61182332, val_rnn_1_1step_R2_maskV_-1.0=0.28896821, val_rnn_1_1step_CC_maskV_-1.0=0.59957445, learning_rate=0.001\n", + "Epoch 85/418 - loss=rnn_1_1step_loss=0.42691159, rnn_1_1step_R2_maskV_-1.0=0.56653315, rnn_1_1step_CC_maskV_-1.0=0.75666362, rnn_1_1step_MSE_maskV_-1.0=0.42691156, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52743083, val_rnn_1_1step_R2_maskV_-1.0=0.38143852, val_rnn_1_1step_CC_maskV_-1.0=0.67051852, learning_rate=0.001\n", + "Epoch 127/418 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40216398, rnn_1_1step_R2_maskV_-1.0=0.59192383, rnn_1_1step_CC_maskV_-1.0=0.77259421, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5087676, val_rnn_1_1step_R2_maskV_-1.0=0.40177056, val_rnn_1_1step_CC_maskV_-1.0=0.68796593, learning_rate=0.001\n", + "Epoch 169/418 - loss=rnn_1_1step_loss=0.39440408, rnn_1_1step_R2_maskV_-1.0=0.59980994, rnn_1_1step_CC_maskV_-1.0=0.77756733, rnn_1_1step_MSE_maskV_-1.0=0.39440411, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50769562, val_rnn_1_1step_R2_maskV_-1.0=0.40280384, val_rnn_1_1step_CC_maskV_-1.0=0.69021028, learning_rate=0.001\n", + "Epoch 211/418 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39176711, rnn_1_1step_R2_maskV_-1.0=0.60245061, rnn_1_1step_CC_maskV_-1.0=0.77924025, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50724697, val_rnn_1_1step_R2_maskV_-1.0=0.40341821, val_rnn_1_1step_CC_maskV_-1.0=0.69100744, learning_rate=0.001\n", + "Epoch 253/418 - loss=rnn_1_1step_loss=0.3907713, rnn_1_1step_R2_maskV_-1.0=0.60340881, rnn_1_1step_CC_maskV_-1.0=0.77986193, rnn_1_1step_MSE_maskV_-1.0=0.39077133, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5065468, val_rnn_1_1step_R2_maskV_-1.0=0.40430522, val_rnn_1_1step_CC_maskV_-1.0=0.69163632, learning_rate=0.001\n", + "Epoch 295/418 - loss=rnn_1_1step_loss=0.39022323, rnn_1_1step_R2_maskV_-1.0=0.60390908, rnn_1_1step_CC_maskV_-1.0=0.7802043, rnn_1_1step_MSE_maskV_-1.0=0.39022321, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50592136, val_rnn_1_1step_R2_maskV_-1.0=0.40508142, val_rnn_1_1step_CC_maskV_-1.0=0.69209188, learning_rate=0.001\n", + "Epoch 337/418 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38970158, rnn_1_1step_R2_maskV_-1.0=0.60438251, rnn_1_1step_CC_maskV_-1.0=0.78053784, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50536531, val_rnn_1_1step_R2_maskV_-1.0=0.405774, val_rnn_1_1step_CC_maskV_-1.0=0.69245481, learning_rate=0.001\n", + "Epoch 379/418 - loss=rnn_1_1step_loss=0.38904765, rnn_1_1step_R2_maskV_-1.0=0.60498816, rnn_1_1step_CC_maskV_-1.0=0.78096199, rnn_1_1step_MSE_maskV_-1.0=0.38904768, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5048117, val_rnn_1_1step_R2_maskV_-1.0=0.40646622, val_rnn_1_1step_CC_maskV_-1.0=0.69280255, learning_rate=0.001\n", + "Epoch 418/418 - loss=rnn_1_1step_loss=0.38823628, rnn_1_1step_R2_maskV_-1.0=0.60575306, rnn_1_1step_CC_maskV_-1.0=0.78149009, rnn_1_1step_MSE_maskV_-1.0=0.38823634, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50424904, val_rnn_1_1step_R2_maskV_-1.0=0.40719238, val_rnn_1_1step_CC_maskV_-1.0=0.69320482, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:21:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 35.99s\n", + "\u001b[32m2025-05-30 15:21:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.50376266)\n", + "\u001b[32m2025-05-30 15:21:04\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.35, R2_maskV_-1.0=0.65, CC_maskV_-1.0=0.807\n", + "\u001b[32m2025-05-30 15:21:04\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.48, R2_maskV_-1.0=0.447, CC_maskV_-1.0=0.715\n", + "\u001b[32m2025-05-30 15:21:04\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:21:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:21:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 154 (stopped at 169 epochs).\n", + "\u001b[32m2025-05-30 15:21:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/170 - loss=4.433372, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.023010829, MSE_maskV_-1.0=4.4234228, val_loss=1.3344613, val_CC_maskV_-1.0=0.068914674, val_MSE_maskV_-1.0=1.3288292, learning_rate=0.001\n", + "Epoch 18/170 - loss=0.828143, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41508985, MSE_maskV_-1.0=0.82847631, val_loss=0.86684299, val_CC_maskV_-1.0=0.40086156, val_MSE_maskV_-1.0=0.86442339, learning_rate=0.001\n", + "Epoch 35/170 - loss=0.7534346, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49593517, MSE_maskV_-1.0=0.75317931, val_loss=0.79912245, val_CC_maskV_-1.0=0.47305623, val_MSE_maskV_-1.0=0.79741132, learning_rate=0.001\n", + "Epoch 52/170 - loss=0.71920723, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52843893, MSE_maskV_-1.0=0.7207858, val_loss=0.76397139, val_CC_maskV_-1.0=0.50659031, val_MSE_maskV_-1.0=0.76186192, learning_rate=0.001\n", + "Epoch 69/170 - loss=0.70109069, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54462206, MSE_maskV_-1.0=0.70067757, val_loss=0.74397731, val_CC_maskV_-1.0=0.52620482, val_MSE_maskV_-1.0=0.74178344, learning_rate=0.001\n", + "Epoch 86/170 - loss=0.69080454, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55406582, MSE_maskV_-1.0=0.69031823, val_loss=0.74043101, val_CC_maskV_-1.0=0.52981943, val_MSE_maskV_-1.0=0.73798513, learning_rate=0.001\n", + "Epoch 103/170 - loss=0.68538338, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55834556, MSE_maskV_-1.0=0.68532884, val_loss=0.73391205, val_CC_maskV_-1.0=0.53545976, val_MSE_maskV_-1.0=0.73139513, learning_rate=0.001\n", + "Epoch 120/170 - loss=0.67849743, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56457675, MSE_maskV_-1.0=0.67860883, val_loss=0.73161077, val_CC_maskV_-1.0=0.53808969, val_MSE_maskV_-1.0=0.72913188, learning_rate=0.001\n", + "Epoch 137/170 - loss=0.67248648, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56976199, MSE_maskV_-1.0=0.6721974, val_loss=0.72116709, val_CC_maskV_-1.0=0.54445404, val_MSE_maskV_-1.0=0.71910572, learning_rate=0.001\n", + "Epoch 154/170 - loss=0.66976154, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57157004, MSE_maskV_-1.0=0.6696763, val_loss=0.71344483, val_CC_maskV_-1.0=0.55255824, val_MSE_maskV_-1.0=0.71124697, learning_rate=0.001\n", + "Epoch 170/170 - loss=0.6672169, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57499188, MSE_maskV_-1.0=0.66726166, val_loss=0.71644461, val_CC_maskV_-1.0=0.55081981, val_MSE_maskV_-1.0=0.71432883, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:21:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 43.49s\n", + "\u001b[32m2025-05-30 15:21:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:22:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 104 (stopped at 119 epochs).\n", + "\u001b[32m2025-05-30 15:22:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/120 - loss=3.9025381, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.042415708, MSE_maskV_-1.0=3.8938606, val_loss=1.2880729, val_CC_maskV_-1.0=0.069824606, val_MSE_maskV_-1.0=1.2878424, learning_rate=0.001\n", + "Epoch 13/120 - loss=0.87276071, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35861814, MSE_maskV_-1.0=0.87183166, val_loss=0.91459846, val_CC_maskV_-1.0=0.3386583, val_MSE_maskV_-1.0=0.91312742, learning_rate=0.001\n", + "Epoch 25/120 - loss=0.78922689, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45956767, MSE_maskV_-1.0=0.78950775, val_loss=0.83916104, val_CC_maskV_-1.0=0.43546659, val_MSE_maskV_-1.0=0.83742404, learning_rate=0.001\n", + "Epoch 37/120 - loss=0.74534363, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50364357, MSE_maskV_-1.0=0.74555629, val_loss=0.78768247, val_CC_maskV_-1.0=0.48678485, val_MSE_maskV_-1.0=0.7858541, learning_rate=0.001\n", + "Epoch 49/120 - loss=0.71829849, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5287928, MSE_maskV_-1.0=0.71829051, val_loss=0.76730525, val_CC_maskV_-1.0=0.50603902, val_MSE_maskV_-1.0=0.76600617, learning_rate=0.001\n", + "Epoch 61/120 - loss=0.70103908, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54543251, MSE_maskV_-1.0=0.70117497, val_loss=0.73974282, val_CC_maskV_-1.0=0.52971458, val_MSE_maskV_-1.0=0.73756707, learning_rate=0.001\n", + "Epoch 73/120 - loss=0.69264877, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5510692, MSE_maskV_-1.0=0.69291079, val_loss=0.73450667, val_CC_maskV_-1.0=0.53382498, val_MSE_maskV_-1.0=0.73284996, learning_rate=0.001\n", + "Epoch 85/120 - loss=0.68563986, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55821204, MSE_maskV_-1.0=0.68574035, val_loss=0.73008054, val_CC_maskV_-1.0=0.53570288, val_MSE_maskV_-1.0=0.72867972, learning_rate=0.001\n", + "Epoch 97/120 - loss=0.68140972, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56222194, MSE_maskV_-1.0=0.68099487, val_loss=0.72716439, val_CC_maskV_-1.0=0.5394358, val_MSE_maskV_-1.0=0.72584677, learning_rate=0.001\n", + "Epoch 109/120 - loss=0.67586333, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56672597, MSE_maskV_-1.0=0.67561656, val_loss=0.71987087, val_CC_maskV_-1.0=0.54540366, val_MSE_maskV_-1.0=0.71850932, learning_rate=0.001\n", + "Epoch 120/120 - loss=0.67575759, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56654799, MSE_maskV_-1.0=0.67582399, val_loss=0.7198115, val_CC_maskV_-1.0=0.54529661, val_MSE_maskV_-1.0=0.71854258, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:22:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 31.02s\n", + "\u001b[32m2025-05-30 15:22:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.71344483)\n", + "\u001b[32m2025-05-30 15:22:18\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 726us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:22:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.659, R2_maskV_-1.0=0.343, CC_maskV_-1.0=0.585\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 770us/step\n", + "51/51 [==============================] - 0s 742us/step\n", + "84/84 [==============================] - 0s 729us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:22:19\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_Cy1HL64U_ErSV16\" (5/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_Cy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:22:19\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_uAK1HL64U_ErSV16\" (6/16)\n", + "\u001b[32m2025-05-30 15:22:19\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAK1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:22:19\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:22:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:22:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:22:20\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:22:20\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:22:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:22:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 142 (stopped at 157 epochs).\n", + "\u001b[32m2025-05-30 15:22:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/158 - loss=rnn_1step_loss=1.0008987, rnn_1step_R2_maskV_-1.0=-0.013551395, rnn_1step_CC_maskV_-1.0=0.082732111, rnn_1step_MSE_maskV_-1.0=1.0008988, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92056531, val_rnn_1step_R2_maskV_-1.0=-0.061588496, val_rnn_1step_CC_maskV_-1.0=0.2594313, learning_rate=0.001\n", + "Epoch 17/158 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.66455215, rnn_1step_R2_maskV_-1.0=0.32239065, rnn_1step_CC_maskV_-1.0=0.58052409, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.67981654, val_rnn_1step_R2_maskV_-1.0=0.21095906, val_rnn_1step_CC_maskV_-1.0=0.51749504, learning_rate=0.001\n", + "Epoch 33/158 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.50615263, rnn_1step_R2_maskV_-1.0=0.48283967, rnn_1step_CC_maskV_-1.0=0.70214355, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59317124, val_rnn_1step_R2_maskV_-1.0=0.31024727, val_rnn_1step_CC_maskV_-1.0=0.60712862, learning_rate=0.001\n", + "Epoch 49/158 - loss=rnn_1step_loss=0.37318075, rnn_1step_R2_maskV_-1.0=0.61959469, rnn_1step_CC_maskV_-1.0=0.7913754, rnn_1step_MSE_maskV_-1.0=0.37318078, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51369053, val_rnn_1step_R2_maskV_-1.0=0.40195078, val_rnn_1step_CC_maskV_-1.0=0.67492747, learning_rate=0.001\n", + "Epoch 65/158 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30116323, rnn_1step_R2_maskV_-1.0=0.69435751, rnn_1step_CC_maskV_-1.0=0.83635795, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47674957, val_rnn_1step_R2_maskV_-1.0=0.44499767, val_rnn_1step_CC_maskV_-1.0=0.70404917, learning_rate=0.001\n", + "Epoch 81/158 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.26241305, rnn_1step_R2_maskV_-1.0=0.73422837, rnn_1step_CC_maskV_-1.0=0.85834932, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47845757, val_rnn_1step_R2_maskV_-1.0=0.44290292, val_rnn_1step_CC_maskV_-1.0=0.70856863, learning_rate=0.001\n", + "Epoch 97/158 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.24123847, rnn_1step_R2_maskV_-1.0=0.75532818, rnn_1step_CC_maskV_-1.0=0.87088019, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46499333, val_rnn_1step_R2_maskV_-1.0=0.46000564, val_rnn_1step_CC_maskV_-1.0=0.71707249, learning_rate=0.001\n", + "Epoch 113/158 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.22073616, rnn_1step_R2_maskV_-1.0=0.77618802, rnn_1step_CC_maskV_-1.0=0.88247019, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4644042, val_rnn_1step_R2_maskV_-1.0=0.46140021, val_rnn_1step_CC_maskV_-1.0=0.72045934, learning_rate=0.001\n", + "Epoch 129/158 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.21125461, rnn_1step_R2_maskV_-1.0=0.78577733, rnn_1step_CC_maskV_-1.0=0.88775265, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4516131, val_rnn_1step_R2_maskV_-1.0=0.47617757, val_rnn_1step_CC_maskV_-1.0=0.72822875, learning_rate=0.001\n", + "Epoch 145/158 - loss=rnn_1step_loss=0.20314856, rnn_1step_R2_maskV_-1.0=0.79390579, rnn_1step_CC_maskV_-1.0=0.89243698, rnn_1step_MSE_maskV_-1.0=0.20314857, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45980048, val_rnn_1step_R2_maskV_-1.0=0.46496958, val_rnn_1step_CC_maskV_-1.0=0.72496784, learning_rate=0.001\n", + "Epoch 158/158 - loss=rnn_1step_loss=0.20285785, rnn_1step_R2_maskV_-1.0=0.79445171, rnn_1step_CC_maskV_-1.0=0.89287645, rnn_1step_MSE_maskV_-1.0=0.20285787, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45832619, val_rnn_1step_R2_maskV_-1.0=0.46891591, val_rnn_1step_CC_maskV_-1.0=0.72636813, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:22:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 18.39s\n", + "\u001b[32m2025-05-30 15:22:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:22:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 62 (stopped at 77 epochs).\n", + "\u001b[32m2025-05-30 15:22:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/78 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0006281, rnn_1_1step_R2_maskV_-1.0=-0.013275806, rnn_1_1step_CC_maskV_-1.0=0.12864187, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92197037, val_rnn_1_1step_R2_maskV_-1.0=-0.063190728, val_rnn_1_1step_CC_maskV_-1.0=0.23823339, learning_rate=0.001\n", + "Epoch 9/78 - loss=rnn_1_1step_loss=0.89796251, rnn_1_1step_R2_maskV_-1.0=0.090781197, rnn_1_1step_CC_maskV_-1.0=0.42919493, rnn_1_1step_MSE_maskV_-1.0=0.89796257, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.82567453, val_rnn_1_1step_R2_maskV_-1.0=0.045662031, val_rnn_1_1step_CC_maskV_-1.0=0.35942912, learning_rate=0.001\n", + "Epoch 17/78 - loss=rnn_1_1step_loss=0.66954666, rnn_1_1step_R2_maskV_-1.0=0.31664306, rnn_1_1step_CC_maskV_-1.0=0.5752449, rnn_1_1step_MSE_maskV_-1.0=0.66954672, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.68384355, val_rnn_1_1step_R2_maskV_-1.0=0.2066634, val_rnn_1_1step_CC_maskV_-1.0=0.5245958, learning_rate=0.001\n", + "Epoch 25/78 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.57078809, rnn_1_1step_R2_maskV_-1.0=0.41675574, rnn_1_1step_CC_maskV_-1.0=0.65564549, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61753839, val_rnn_1_1step_R2_maskV_-1.0=0.28306878, val_rnn_1_1step_CC_maskV_-1.0=0.57890803, learning_rate=0.001\n", + "Epoch 33/78 - loss=rnn_1_1step_loss=0.49642345, rnn_1_1step_R2_maskV_-1.0=0.49249128, rnn_1_1step_CC_maskV_-1.0=0.70977414, rnn_1_1step_MSE_maskV_-1.0=0.49642342, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57824218, val_rnn_1_1step_R2_maskV_-1.0=0.32622281, val_rnn_1_1step_CC_maskV_-1.0=0.62093085, learning_rate=0.001\n", + "Epoch 41/78 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42411402, rnn_1_1step_R2_maskV_-1.0=0.56663215, rnn_1_1step_CC_maskV_-1.0=0.75977981, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54149723, val_rnn_1_1step_R2_maskV_-1.0=0.36697406, val_rnn_1_1step_CC_maskV_-1.0=0.65777665, learning_rate=0.001\n", + "Epoch 49/78 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39334869, rnn_1_1step_R2_maskV_-1.0=0.59912062, rnn_1_1step_CC_maskV_-1.0=0.78090888, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58057648, val_rnn_1_1step_R2_maskV_-1.0=0.31857407, val_rnn_1_1step_CC_maskV_-1.0=0.65011531, learning_rate=0.001\n", + "Epoch 57/78 - loss=rnn_1_1step_loss=0.3500948, rnn_1_1step_R2_maskV_-1.0=0.64329433, rnn_1_1step_CC_maskV_-1.0=0.80611211, rnn_1_1step_MSE_maskV_-1.0=0.35009483, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52131224, val_rnn_1_1step_R2_maskV_-1.0=0.38947514, val_rnn_1_1step_CC_maskV_-1.0=0.6778509, learning_rate=0.001\n", + "Epoch 65/78 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32602319, rnn_1_1step_R2_maskV_-1.0=0.66807038, rnn_1_1step_CC_maskV_-1.0=0.82095033, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51898664, val_rnn_1_1step_R2_maskV_-1.0=0.39279988, val_rnn_1_1step_CC_maskV_-1.0=0.68133813, learning_rate=0.001\n", + "Epoch 73/78 - loss=rnn_1_1step_loss=0.30670676, rnn_1_1step_R2_maskV_-1.0=0.68797398, rnn_1_1step_CC_maskV_-1.0=0.83198494, rnn_1_1step_MSE_maskV_-1.0=0.30670679, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53425592, val_rnn_1_1step_R2_maskV_-1.0=0.37486988, val_rnn_1_1step_CC_maskV_-1.0=0.67700726, learning_rate=0.001\n", + "Epoch 78/78 - loss=rnn_1_1step_loss=0.29467937, rnn_1_1step_R2_maskV_-1.0=0.70022428, rnn_1_1step_CC_maskV_-1.0=0.83953691, rnn_1_1step_MSE_maskV_-1.0=0.2946794, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53073752, val_rnn_1_1step_R2_maskV_-1.0=0.37957186, val_rnn_1_1step_CC_maskV_-1.0=0.68252611, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:22:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.33s\n", + "\u001b[32m2025-05-30 15:22:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.44193897)\n", + "\u001b[32m2025-05-30 15:22:50\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.188, R2_maskV_-1.0=0.812, CC_maskV_-1.0=0.901\n", + "\u001b[32m2025-05-30 15:22:50\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.411, R2_maskV_-1.0=0.531, CC_maskV_-1.0=0.759\n", + "\u001b[32m2025-05-30 15:22:50\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:22:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:23:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 231 (stopped at 246 epochs).\n", + "\u001b[32m2025-05-30 15:23:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/247 - loss=1.6448886, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.035916436, MSE_maskV_-1.0=1.6433351, val_loss=1.0958043, val_CC_maskV_-1.0=0.092535876, val_MSE_maskV_-1.0=1.0967515, learning_rate=0.001\n", + "Epoch 26/247 - loss=0.90400082, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.31542575, MSE_maskV_-1.0=0.90420091, val_loss=0.9395355, val_CC_maskV_-1.0=0.31351987, val_MSE_maskV_-1.0=0.9360342, learning_rate=0.001\n", + "Epoch 51/247 - loss=0.88115406, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34980097, MSE_maskV_-1.0=0.88064706, val_loss=0.91577131, val_CC_maskV_-1.0=0.34772804, val_MSE_maskV_-1.0=0.91231483, learning_rate=0.001\n", + "Epoch 76/247 - loss=0.86786938, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36876231, MSE_maskV_-1.0=0.86746103, val_loss=0.90243477, val_CC_maskV_-1.0=0.36237949, val_MSE_maskV_-1.0=0.89953846, learning_rate=0.001\n", + "Epoch 101/247 - loss=0.85870588, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38091111, MSE_maskV_-1.0=0.8578434, val_loss=0.89539826, val_CC_maskV_-1.0=0.37107459, val_MSE_maskV_-1.0=0.89213294, learning_rate=0.001\n", + "Epoch 126/247 - loss=0.85210782, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38862655, MSE_maskV_-1.0=0.85185635, val_loss=0.8865791, val_CC_maskV_-1.0=0.38098934, val_MSE_maskV_-1.0=0.88345253, learning_rate=0.001\n", + "Epoch 151/247 - loss=0.8470397, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39453483, MSE_maskV_-1.0=0.84704792, val_loss=0.88387251, val_CC_maskV_-1.0=0.38285831, val_MSE_maskV_-1.0=0.88105214, learning_rate=0.001\n", + "Epoch 176/247 - loss=0.84319299, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39795029, MSE_maskV_-1.0=0.84246796, val_loss=0.87902337, val_CC_maskV_-1.0=0.38778687, val_MSE_maskV_-1.0=0.87580496, learning_rate=0.001\n", + "Epoch 201/247 - loss=0.8398487, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40253353, MSE_maskV_-1.0=0.83947247, val_loss=0.87737364, val_CC_maskV_-1.0=0.3866221, val_MSE_maskV_-1.0=0.87476867, learning_rate=0.001\n", + "Epoch 226/247 - loss=0.83721381, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4047128, MSE_maskV_-1.0=0.83686018, val_loss=0.87549645, val_CC_maskV_-1.0=0.38917604, val_MSE_maskV_-1.0=0.8727141, learning_rate=0.001\n", + "Epoch 247/247 - loss=0.83562028, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40669954, MSE_maskV_-1.0=0.83502173, val_loss=0.87433451, val_CC_maskV_-1.0=0.39047471, val_MSE_maskV_-1.0=0.87167692, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:23:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 58.40s\n", + "\u001b[32m2025-05-30 15:23:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:24:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 231 (stopped at 246 epochs).\n", + "\u001b[32m2025-05-30 15:24:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/247 - loss=1.674731, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.053961031, MSE_maskV_-1.0=1.6730895, val_loss=1.0821856, val_CC_maskV_-1.0=0.11654749, val_MSE_maskV_-1.0=1.0817961, learning_rate=0.001\n", + "Epoch 26/247 - loss=0.90385008, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.31578866, MSE_maskV_-1.0=0.90403461, val_loss=0.93659753, val_CC_maskV_-1.0=0.31769621, val_MSE_maskV_-1.0=0.93341476, learning_rate=0.001\n", + "Epoch 51/247 - loss=0.88115513, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34972584, MSE_maskV_-1.0=0.88066238, val_loss=0.91356647, val_CC_maskV_-1.0=0.35078603, val_MSE_maskV_-1.0=0.91024506, learning_rate=0.001\n", + "Epoch 76/247 - loss=0.86782873, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36886349, MSE_maskV_-1.0=0.86742085, val_loss=0.90083319, val_CC_maskV_-1.0=0.36432806, val_MSE_maskV_-1.0=0.89802104, learning_rate=0.001\n", + "Epoch 101/247 - loss=0.85866904, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38097072, MSE_maskV_-1.0=0.85781747, val_loss=0.89389491, val_CC_maskV_-1.0=0.37301633, val_MSE_maskV_-1.0=0.89063627, learning_rate=0.001\n", + "Epoch 126/247 - loss=0.85206097, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38865942, MSE_maskV_-1.0=0.85182267, val_loss=0.88530499, val_CC_maskV_-1.0=0.38254884, val_MSE_maskV_-1.0=0.88219482, learning_rate=0.001\n", + "Epoch 151/247 - loss=0.84699661, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39460427, MSE_maskV_-1.0=0.84701604, val_loss=0.88284397, val_CC_maskV_-1.0=0.38409993, val_MSE_maskV_-1.0=0.88003451, learning_rate=0.001\n", + "Epoch 176/247 - loss=0.84315544, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39801222, MSE_maskV_-1.0=0.84243053, val_loss=0.87804824, val_CC_maskV_-1.0=0.38892022, val_MSE_maskV_-1.0=0.87482888, learning_rate=0.001\n", + "Epoch 201/247 - loss=0.83982611, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40255487, MSE_maskV_-1.0=0.83945733, val_loss=0.87649727, val_CC_maskV_-1.0=0.38766614, val_MSE_maskV_-1.0=0.87388885, learning_rate=0.001\n", + "Epoch 226/247 - loss=0.83719474, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40473083, MSE_maskV_-1.0=0.83684051, val_loss=0.87467146, val_CC_maskV_-1.0=0.39014801, val_MSE_maskV_-1.0=0.87187511, learning_rate=0.001\n", + "Epoch 247/247 - loss=0.83560878, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40672174, MSE_maskV_-1.0=0.83501089, val_loss=0.87357283, val_CC_maskV_-1.0=0.39136392, val_MSE_maskV_-1.0=0.87091708, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:24:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 58.59s\n", + "\u001b[32m2025-05-30 15:24:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.87049747)\n", + "\u001b[32m2025-05-30 15:24:47\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 706us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:24:47\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.836, R2_maskV_-1.0=0.165, CC_maskV_-1.0=0.408\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 726us/step\n", + "51/51 [==============================] - 0s 778us/step\n", + "84/84 [==============================] - 0s 663us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:24:48\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_uAK1HL64U_ErSV16\" (6/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_uAK1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:24:48\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_ACz1HL64U_ErSV16\" (7/16)\n", + "\u001b[32m2025-05-30 15:24:48\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:24:48\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:24:48\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:24:48\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:24:48\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:24:48\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:24:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:25:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 260 (stopped at 275 epochs).\n", + "\u001b[32m2025-05-30 15:25:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/276 - loss=rnn_1step_loss=1.0009841, rnn_1step_R2_maskV_-1.0=-0.01363745, rnn_1step_CC_maskV_-1.0=0.074794121, rnn_1step_MSE_maskV_-1.0=1.000984, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92167163, val_rnn_1step_R2_maskV_-1.0=-0.063012615, val_rnn_1step_CC_maskV_-1.0=0.24287671, learning_rate=0.001\n", + "Epoch 29/276 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.56655079, rnn_1step_R2_maskV_-1.0=0.42115915, rnn_1step_CC_maskV_-1.0=0.65938473, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62965459, val_rnn_1step_R2_maskV_-1.0=0.26986706, val_rnn_1step_CC_maskV_-1.0=0.57153773, learning_rate=0.001\n", + "Epoch 57/276 - loss=rnn_1step_loss=0.46684828, rnn_1step_R2_maskV_-1.0=0.52332538, rnn_1step_CC_maskV_-1.0=0.73066735, rnn_1step_MSE_maskV_-1.0=0.46684834, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58772284, val_rnn_1step_R2_maskV_-1.0=0.31798202, val_rnn_1step_CC_maskV_-1.0=0.61814553, learning_rate=0.001\n", + "Epoch 85/276 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.44516811, rnn_1step_R2_maskV_-1.0=0.54605418, rnn_1step_CC_maskV_-1.0=0.75009251, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56487268, val_rnn_1step_R2_maskV_-1.0=0.341692, val_rnn_1step_CC_maskV_-1.0=0.63249475, learning_rate=0.001\n", + "Epoch 113/276 - loss=rnn_1step_loss=0.38144755, rnn_1step_R2_maskV_-1.0=0.61111581, rnn_1step_CC_maskV_-1.0=0.78666604, rnn_1step_MSE_maskV_-1.0=0.38144752, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50877976, val_rnn_1step_R2_maskV_-1.0=0.40551785, val_rnn_1step_CC_maskV_-1.0=0.68127513, learning_rate=0.001\n", + "Epoch 141/276 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35457718, rnn_1step_R2_maskV_-1.0=0.63892215, rnn_1step_CC_maskV_-1.0=0.80517197, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4590033, val_rnn_1step_R2_maskV_-1.0=0.46565452, val_rnn_1step_CC_maskV_-1.0=0.71152776, learning_rate=0.001\n", + "Epoch 169/276 - loss=rnn_1step_loss=0.33317313, rnn_1step_R2_maskV_-1.0=0.66077477, rnn_1step_CC_maskV_-1.0=0.81769836, rnn_1step_MSE_maskV_-1.0=0.3331731, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45144042, val_rnn_1step_R2_maskV_-1.0=0.47477171, val_rnn_1step_CC_maskV_-1.0=0.71652555, learning_rate=0.001\n", + "Epoch 197/276 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31891492, rnn_1step_R2_maskV_-1.0=0.67564368, rnn_1step_CC_maskV_-1.0=0.82586241, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44447532, val_rnn_1step_R2_maskV_-1.0=0.48269415, val_rnn_1step_CC_maskV_-1.0=0.72231108, learning_rate=0.001\n", + "Epoch 225/276 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31548044, rnn_1step_R2_maskV_-1.0=0.67933178, rnn_1step_CC_maskV_-1.0=0.8289097, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44107962, val_rnn_1step_R2_maskV_-1.0=0.48640633, val_rnn_1step_CC_maskV_-1.0=0.72573113, learning_rate=0.001\n", + "Epoch 253/276 - loss=rnn_1step_loss=0.313912, rnn_1step_R2_maskV_-1.0=0.68066651, rnn_1step_CC_maskV_-1.0=0.8306818, rnn_1step_MSE_maskV_-1.0=0.31391203, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42801046, val_rnn_1step_R2_maskV_-1.0=0.50196779, val_rnn_1step_CC_maskV_-1.0=0.73346061, learning_rate=0.001\n", + "Epoch 276/276 - loss=rnn_1step_loss=0.3017275, rnn_1step_R2_maskV_-1.0=0.69313562, rnn_1step_CC_maskV_-1.0=0.8368125, rnn_1step_MSE_maskV_-1.0=0.30172753, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.41993555, val_rnn_1step_R2_maskV_-1.0=0.51053715, val_rnn_1step_CC_maskV_-1.0=0.73981732, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:25:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 31.18s\n", + "\u001b[32m2025-05-30 15:25:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:25:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 101 (stopped at 116 epochs).\n", + "\u001b[32m2025-05-30 15:25:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/117 - loss=rnn_1_1step_loss=1.0007789, rnn_1_1step_R2_maskV_-1.0=-0.013392832, rnn_1_1step_CC_maskV_-1.0=0.10616057, rnn_1_1step_MSE_maskV_-1.0=1.000779, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92095309, val_rnn_1_1step_R2_maskV_-1.0=-0.062143266, val_rnn_1_1step_CC_maskV_-1.0=0.30250901, learning_rate=0.001\n", + "Epoch 13/117 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.81666917, rnn_1_1step_R2_maskV_-1.0=0.17402552, rnn_1_1step_CC_maskV_-1.0=0.43349665, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.76357061, val_rnn_1_1step_R2_maskV_-1.0=0.10964987, val_rnn_1_1step_CC_maskV_-1.0=0.41980565, learning_rate=0.001\n", + "Epoch 25/117 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.62108213, rnn_1_1step_R2_maskV_-1.0=0.37019256, rnn_1_1step_CC_maskV_-1.0=0.61566657, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.66522646, val_rnn_1_1step_R2_maskV_-1.0=0.22415103, val_rnn_1_1step_CC_maskV_-1.0=0.54559147, learning_rate=0.001\n", + "Epoch 37/117 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.50257111, rnn_1_1step_R2_maskV_-1.0=0.48913544, rnn_1_1step_CC_maskV_-1.0=0.70503616, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59095615, val_rnn_1_1step_R2_maskV_-1.0=0.30852747, val_rnn_1_1step_CC_maskV_-1.0=0.62034404, learning_rate=0.001\n", + "Epoch 49/117 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.43452081, rnn_1_1step_R2_maskV_-1.0=0.558263, rnn_1_1step_CC_maskV_-1.0=0.75148916, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55024594, val_rnn_1_1step_R2_maskV_-1.0=0.35318673, val_rnn_1_1step_CC_maskV_-1.0=0.65917718, learning_rate=0.001\n", + "Epoch 61/117 - loss=rnn_1_1step_loss=0.40621886, rnn_1_1step_R2_maskV_-1.0=0.58692312, rnn_1_1step_CC_maskV_-1.0=0.77085871, rnn_1_1step_MSE_maskV_-1.0=0.40621883, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51821077, val_rnn_1_1step_R2_maskV_-1.0=0.39061591, val_rnn_1_1step_CC_maskV_-1.0=0.67791045, learning_rate=0.001\n", + "Epoch 73/117 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38949117, rnn_1_1step_R2_maskV_-1.0=0.60400712, rnn_1_1step_CC_maskV_-1.0=0.78154594, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50666982, val_rnn_1_1step_R2_maskV_-1.0=0.40426421, val_rnn_1_1step_CC_maskV_-1.0=0.68684036, learning_rate=0.001\n", + "Epoch 85/117 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.37820184, rnn_1_1step_R2_maskV_-1.0=0.61562538, rnn_1_1step_CC_maskV_-1.0=0.78909796, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50374335, val_rnn_1_1step_R2_maskV_-1.0=0.40785545, val_rnn_1_1step_CC_maskV_-1.0=0.68996036, learning_rate=0.001\n", + "Epoch 97/117 - loss=rnn_1_1step_loss=0.36993805, rnn_1_1step_R2_maskV_-1.0=0.62408531, rnn_1_1step_CC_maskV_-1.0=0.79399753, rnn_1_1step_MSE_maskV_-1.0=0.36993808, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49892101, val_rnn_1_1step_R2_maskV_-1.0=0.41400605, val_rnn_1_1step_CC_maskV_-1.0=0.69168943, learning_rate=0.001\n", + "Epoch 109/117 - loss=rnn_1_1step_loss=0.35719606, rnn_1_1step_R2_maskV_-1.0=0.63702714, rnn_1_1step_CC_maskV_-1.0=0.80184144, rnn_1_1step_MSE_maskV_-1.0=0.35719603, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50958532, val_rnn_1_1step_R2_maskV_-1.0=0.40186441, val_rnn_1_1step_CC_maskV_-1.0=0.69157577, learning_rate=0.001\n", + "Epoch 117/117 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.35553741, rnn_1_1step_R2_maskV_-1.0=0.6388129, rnn_1_1step_CC_maskV_-1.0=0.8036623, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49752107, val_rnn_1_1step_R2_maskV_-1.0=0.41886756, val_rnn_1_1step_CC_maskV_-1.0=0.69184136, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:25:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.48s\n", + "\u001b[32m2025-05-30 15:25:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.41452089)\n", + "\u001b[32m2025-05-30 15:25:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.281, R2_maskV_-1.0=0.719, CC_maskV_-1.0=0.849\n", + "\u001b[32m2025-05-30 15:25:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.411, R2_maskV_-1.0=0.531, CC_maskV_-1.0=0.753\n", + "\u001b[32m2025-05-30 15:25:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:25:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:26:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 99 (stopped at 114 epochs).\n", + "\u001b[32m2025-05-30 15:26:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/115 - loss=6.1992102, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.029848959, MSE_maskV_-1.0=6.1848536, val_loss=1.8478872, val_CC_maskV_-1.0=0.087460347, val_MSE_maskV_-1.0=1.8361545, learning_rate=0.001\n", + "Epoch 13/115 - loss=0.80391675, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44318655, MSE_maskV_-1.0=0.80318415, val_loss=0.83175594, val_CC_maskV_-1.0=0.44112602, val_MSE_maskV_-1.0=0.82986957, learning_rate=0.001\n", + "Epoch 25/115 - loss=0.7541433, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49580559, MSE_maskV_-1.0=0.75453275, val_loss=0.78962588, val_CC_maskV_-1.0=0.48352775, val_MSE_maskV_-1.0=0.78821611, learning_rate=0.001\n", + "Epoch 37/115 - loss=0.7376408, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51191211, MSE_maskV_-1.0=0.73778355, val_loss=0.77051961, val_CC_maskV_-1.0=0.50182629, val_MSE_maskV_-1.0=0.76933706, learning_rate=0.001\n", + "Epoch 49/115 - loss=0.72854686, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5202539, MSE_maskV_-1.0=0.72857785, val_loss=0.76873815, val_CC_maskV_-1.0=0.50396931, val_MSE_maskV_-1.0=0.76764834, learning_rate=0.001\n", + "Epoch 61/115 - loss=0.72594118, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52312213, MSE_maskV_-1.0=0.72598183, val_loss=0.75831193, val_CC_maskV_-1.0=0.512573, val_MSE_maskV_-1.0=0.75741965, learning_rate=0.001\n", + "Epoch 73/115 - loss=0.72244221, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52537864, MSE_maskV_-1.0=0.72269779, val_loss=0.75785583, val_CC_maskV_-1.0=0.51328605, val_MSE_maskV_-1.0=0.75703788, learning_rate=0.001\n", + "Epoch 85/115 - loss=0.72127539, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52734673, MSE_maskV_-1.0=0.7211656, val_loss=0.75555205, val_CC_maskV_-1.0=0.51517504, val_MSE_maskV_-1.0=0.75501931, learning_rate=0.001\n", + "Epoch 97/115 - loss=0.72005838, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52867001, MSE_maskV_-1.0=0.71973652, val_loss=0.75283653, val_CC_maskV_-1.0=0.51760542, val_MSE_maskV_-1.0=0.75209564, learning_rate=0.001\n", + "Epoch 109/115 - loss=0.71941429, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52925646, MSE_maskV_-1.0=0.71909517, val_loss=0.75242966, val_CC_maskV_-1.0=0.51715714, val_MSE_maskV_-1.0=0.75194532, learning_rate=0.001\n", + "Epoch 115/115 - loss=0.71902412, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52903938, MSE_maskV_-1.0=0.71984315, val_loss=0.75448424, val_CC_maskV_-1.0=0.51561409, val_MSE_maskV_-1.0=0.75394058, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:26:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 28.68s\n", + "\u001b[32m2025-05-30 15:26:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:26:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 99 (stopped at 114 epochs).\n", + "\u001b[32m2025-05-30 15:26:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/115 - loss=6.6643057, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0077240169, MSE_maskV_-1.0=6.6495752, val_loss=2.0600703, val_CC_maskV_-1.0=0.011215225, val_MSE_maskV_-1.0=2.0588541, learning_rate=0.001\n", + "Epoch 13/115 - loss=0.82450241, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41919231, MSE_maskV_-1.0=0.82381284, val_loss=0.85087121, val_CC_maskV_-1.0=0.41558781, val_MSE_maskV_-1.0=0.85012466, learning_rate=0.001\n", + "Epoch 25/115 - loss=0.76440859, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48552442, MSE_maskV_-1.0=0.76479959, val_loss=0.79715341, val_CC_maskV_-1.0=0.4733763, val_MSE_maskV_-1.0=0.79653782, learning_rate=0.001\n", + "Epoch 37/115 - loss=0.74346119, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50621259, MSE_maskV_-1.0=0.7436173, val_loss=0.77404445, val_CC_maskV_-1.0=0.49717039, val_MSE_maskV_-1.0=0.77327651, learning_rate=0.001\n", + "Epoch 49/115 - loss=0.73192668, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51707196, MSE_maskV_-1.0=0.73191816, val_loss=0.77025795, val_CC_maskV_-1.0=0.50170428, val_MSE_maskV_-1.0=0.76942748, learning_rate=0.001\n", + "Epoch 61/115 - loss=0.72792417, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52122182, MSE_maskV_-1.0=0.72798908, val_loss=0.75928468, val_CC_maskV_-1.0=0.5111528, val_MSE_maskV_-1.0=0.75855762, learning_rate=0.001\n", + "Epoch 73/115 - loss=0.7236405, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52423924, MSE_maskV_-1.0=0.72389829, val_loss=0.75843251, val_CC_maskV_-1.0=0.51246929, val_MSE_maskV_-1.0=0.75770855, learning_rate=0.001\n", + "Epoch 85/115 - loss=0.7220695, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52659965, MSE_maskV_-1.0=0.72195435, val_loss=0.75566792, val_CC_maskV_-1.0=0.51488882, val_MSE_maskV_-1.0=0.75519884, learning_rate=0.001\n", + "Epoch 97/115 - loss=0.72054785, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52820671, MSE_maskV_-1.0=0.72022289, val_loss=0.75306201, val_CC_maskV_-1.0=0.51724589, val_MSE_maskV_-1.0=0.75235921, learning_rate=0.001\n", + "Epoch 109/115 - loss=0.71974856, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5289284, MSE_maskV_-1.0=0.71942908, val_loss=0.75262457, val_CC_maskV_-1.0=0.516882, val_MSE_maskV_-1.0=0.75216508, learning_rate=0.001\n", + "Epoch 115/115 - loss=0.71930003, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52877486, MSE_maskV_-1.0=0.72010779, val_loss=0.7545349, val_CC_maskV_-1.0=0.5154835, val_MSE_maskV_-1.0=0.75401258, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:26:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 27.11s\n", + "\u001b[32m2025-05-30 15:26:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.75094467)\n", + "\u001b[32m2025-05-30 15:26:32\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 724us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:26:32\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.719, R2_maskV_-1.0=0.281, CC_maskV_-1.0=0.531\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 704us/step\n", + "51/51 [==============================] - 0s 754us/step\n", + "84/84 [==============================] - 0s 628us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:26:33\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_ACz1HL64U_ErSV16\" (7/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_ACz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:26:33\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_ACy1HL64U_ErSV16\" (8/16)\n", + "\u001b[32m2025-05-30 15:26:33\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:26:33\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:26:33\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:26:33\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:26:33\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:26:33\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:26:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:26:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 169 (stopped at 184 epochs).\n", + "\u001b[32m2025-05-30 15:26:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/185 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.9971776, rnn_1step_R2_maskV_-1.0=-0.0096148327, rnn_1step_CC_maskV_-1.0=0.1080642, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91654205, val_rnn_1step_R2_maskV_-1.0=-0.057391852, val_rnn_1step_CC_maskV_-1.0=0.16450568, learning_rate=0.001\n", + "Epoch 20/185 - loss=rnn_1step_loss=0.6501801, rnn_1step_R2_maskV_-1.0=0.34019279, rnn_1step_CC_maskV_-1.0=0.59227139, rnn_1step_MSE_maskV_-1.0=0.65018016, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.670708, val_rnn_1step_R2_maskV_-1.0=0.2151895, val_rnn_1step_CC_maskV_-1.0=0.5383147, learning_rate=0.001\n", + "Epoch 39/185 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.53827411, rnn_1step_R2_maskV_-1.0=0.45329049, rnn_1step_CC_maskV_-1.0=0.67870331, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61863911, val_rnn_1step_R2_maskV_-1.0=0.28058964, val_rnn_1step_CC_maskV_-1.0=0.58856708, learning_rate=0.001\n", + "Epoch 58/185 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4888078, rnn_1step_R2_maskV_-1.0=0.50382549, rnn_1step_CC_maskV_-1.0=0.71484196, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58493549, val_rnn_1step_R2_maskV_-1.0=0.32025898, val_rnn_1step_CC_maskV_-1.0=0.61650628, learning_rate=0.001\n", + "Epoch 77/185 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.46165887, rnn_1step_R2_maskV_-1.0=0.53136981, rnn_1step_CC_maskV_-1.0=0.73374546, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55938035, val_rnn_1step_R2_maskV_-1.0=0.34874576, val_rnn_1step_CC_maskV_-1.0=0.63643211, learning_rate=0.001\n", + "Epoch 96/185 - loss=rnn_1step_loss=0.44146478, rnn_1step_R2_maskV_-1.0=0.5513941, rnn_1step_CC_maskV_-1.0=0.74936205, rnn_1step_MSE_maskV_-1.0=0.44146475, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54207641, val_rnn_1step_R2_maskV_-1.0=0.36778569, val_rnn_1step_CC_maskV_-1.0=0.64436132, learning_rate=0.001\n", + "Epoch 115/185 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41427124, rnn_1step_R2_maskV_-1.0=0.57906127, rnn_1step_CC_maskV_-1.0=0.76593012, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5332197, val_rnn_1step_R2_maskV_-1.0=0.374924, val_rnn_1step_CC_maskV_-1.0=0.66129583, learning_rate=0.001\n", + "Epoch 134/185 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39906082, rnn_1step_R2_maskV_-1.0=0.5943588, rnn_1step_CC_maskV_-1.0=0.77738899, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49241033, val_rnn_1step_R2_maskV_-1.0=0.42539415, val_rnn_1step_CC_maskV_-1.0=0.68491387, learning_rate=0.001\n", + "Epoch 153/185 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38300276, rnn_1step_R2_maskV_-1.0=0.61079788, rnn_1step_CC_maskV_-1.0=0.7857455, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52225518, val_rnn_1step_R2_maskV_-1.0=0.38905466, val_rnn_1step_CC_maskV_-1.0=0.67155826, learning_rate=0.001\n", + "Epoch 172/185 - loss=rnn_1step_loss=0.37605131, rnn_1step_R2_maskV_-1.0=0.61777472, rnn_1step_CC_maskV_-1.0=0.79106545, rnn_1step_MSE_maskV_-1.0=0.37605134, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51481634, val_rnn_1step_R2_maskV_-1.0=0.3974942, val_rnn_1step_CC_maskV_-1.0=0.67551798, learning_rate=0.001\n", + "Epoch 185/185 - loss=rnn_1step_loss=0.36609498, rnn_1step_R2_maskV_-1.0=0.62782663, rnn_1step_CC_maskV_-1.0=0.79655778, rnn_1step_MSE_maskV_-1.0=0.36609501, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.523974, val_rnn_1step_R2_maskV_-1.0=0.38784498, val_rnn_1step_CC_maskV_-1.0=0.67226082, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:26:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 20.86s\n", + "\u001b[32m2025-05-30 15:26:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:27:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 158 (stopped at 173 epochs).\n", + "\u001b[32m2025-05-30 15:27:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/174 - loss=rnn_1_1step_loss=0.99754936, rnn_1_1step_R2_maskV_-1.0=-0.0099140815, rnn_1_1step_CC_maskV_-1.0=0.094386131, rnn_1_1step_MSE_maskV_-1.0=0.9975493, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91681844, val_rnn_1_1step_R2_maskV_-1.0=-0.057538241, val_rnn_1_1step_CC_maskV_-1.0=0.16506207, learning_rate=0.001\n", + "Epoch 19/174 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.63267338, rnn_1_1step_R2_maskV_-1.0=0.35550916, rnn_1_1step_CC_maskV_-1.0=0.60771799, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.66354609, val_rnn_1_1step_R2_maskV_-1.0=0.22774677, val_rnn_1_1step_CC_maskV_-1.0=0.53719026, learning_rate=0.001\n", + "Epoch 37/174 - loss=rnn_1_1step_loss=0.52471632, rnn_1_1step_R2_maskV_-1.0=0.46475583, rnn_1_1step_CC_maskV_-1.0=0.68906051, rnn_1_1step_MSE_maskV_-1.0=0.52471626, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63255316, val_rnn_1_1step_R2_maskV_-1.0=0.26927409, val_rnn_1_1step_CC_maskV_-1.0=0.57712662, learning_rate=0.001\n", + "Epoch 55/174 - loss=rnn_1_1step_loss=0.47075287, rnn_1_1step_R2_maskV_-1.0=0.52021468, rnn_1_1step_CC_maskV_-1.0=0.72710001, rnn_1_1step_MSE_maskV_-1.0=0.47075289, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61081809, val_rnn_1_1step_R2_maskV_-1.0=0.29471418, val_rnn_1_1step_CC_maskV_-1.0=0.60064614, learning_rate=0.001\n", + "Epoch 73/174 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.4248707, rnn_1_1step_R2_maskV_-1.0=0.5675317, rnn_1_1step_CC_maskV_-1.0=0.75788069, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57716304, val_rnn_1_1step_R2_maskV_-1.0=0.33130705, val_rnn_1_1step_CC_maskV_-1.0=0.63229156, learning_rate=0.001\n", + "Epoch 91/174 - loss=rnn_1_1step_loss=0.37304202, rnn_1_1step_R2_maskV_-1.0=0.62037134, rnn_1_1step_CC_maskV_-1.0=0.79170185, rnn_1_1step_MSE_maskV_-1.0=0.37304205, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53325796, val_rnn_1_1step_R2_maskV_-1.0=0.38042432, val_rnn_1_1step_CC_maskV_-1.0=0.66797709, learning_rate=0.001\n", + "Epoch 109/174 - loss=rnn_1_1step_loss=0.34324417, rnn_1_1step_R2_maskV_-1.0=0.65078688, rnn_1_1step_CC_maskV_-1.0=0.81125414, rnn_1_1step_MSE_maskV_-1.0=0.34324414, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50802916, val_rnn_1_1step_R2_maskV_-1.0=0.4083049, val_rnn_1_1step_CC_maskV_-1.0=0.68699586, learning_rate=0.001\n", + "Epoch 127/174 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33354816, rnn_1_1step_R2_maskV_-1.0=0.66046375, rnn_1_1step_CC_maskV_-1.0=0.81773627, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4762063, val_rnn_1_1step_R2_maskV_-1.0=0.44498694, val_rnn_1_1step_CC_maskV_-1.0=0.7084282, learning_rate=0.001\n", + "Epoch 145/174 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31639168, rnn_1_1step_R2_maskV_-1.0=0.67800748, rnn_1_1step_CC_maskV_-1.0=0.8279916, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45826134, val_rnn_1_1step_R2_maskV_-1.0=0.46502081, val_rnn_1_1step_CC_maskV_-1.0=0.71916288, learning_rate=0.001\n", + "Epoch 163/174 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30810806, rnn_1_1step_R2_maskV_-1.0=0.68714345, rnn_1_1step_CC_maskV_-1.0=0.83164924, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.43606582, val_rnn_1_1step_R2_maskV_-1.0=0.49184373, val_rnn_1_1step_CC_maskV_-1.0=0.73133141, learning_rate=0.001\n", + "Epoch 174/174 - loss=rnn_1_1step_loss=0.30882266, rnn_1_1step_R2_maskV_-1.0=0.68611425, rnn_1_1step_CC_maskV_-1.0=0.83136582, rnn_1_1step_MSE_maskV_-1.0=0.30882269, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.44037405, val_rnn_1_1step_R2_maskV_-1.0=0.48501432, val_rnn_1_1step_CC_maskV_-1.0=0.72840536, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:27:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 19.65s\n", + "\u001b[32m2025-05-30 15:27:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.43144825)\n", + "\u001b[32m2025-05-30 15:27:15\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.283, R2_maskV_-1.0=0.717, CC_maskV_-1.0=0.847\n", + "\u001b[32m2025-05-30 15:27:15\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.423, R2_maskV_-1.0=0.516, CC_maskV_-1.0=0.746\n", + "\u001b[32m2025-05-30 15:27:15\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:27:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:27:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 121 (stopped at 136 epochs).\n", + "\u001b[32m2025-05-30 15:27:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/137 - loss=1.3849047, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.10535771, MSE_maskV_-1.0=1.3839465, val_loss=1.0115405, val_CC_maskV_-1.0=0.20630655, val_MSE_maskV_-1.0=1.0069082, learning_rate=0.001\n", + "Epoch 15/137 - loss=0.70043457, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54606819, MSE_maskV_-1.0=0.70074326, val_loss=0.74489743, val_CC_maskV_-1.0=0.52350467, val_MSE_maskV_-1.0=0.74360746, learning_rate=0.001\n", + "Epoch 29/137 - loss=0.65672833, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58415359, MSE_maskV_-1.0=0.65649611, val_loss=0.71307355, val_CC_maskV_-1.0=0.55267012, val_MSE_maskV_-1.0=0.71231902, learning_rate=0.001\n", + "Epoch 43/137 - loss=0.64013529, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59789979, MSE_maskV_-1.0=0.64002585, val_loss=0.70177782, val_CC_maskV_-1.0=0.56210351, val_MSE_maskV_-1.0=0.7013309, learning_rate=0.001\n", + "Epoch 57/137 - loss=0.63120025, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60537672, MSE_maskV_-1.0=0.63163441, val_loss=0.69988728, val_CC_maskV_-1.0=0.56455487, val_MSE_maskV_-1.0=0.69949919, learning_rate=0.001\n", + "Epoch 71/137 - loss=0.62414426, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61117017, MSE_maskV_-1.0=0.6261394, val_loss=0.69360882, val_CC_maskV_-1.0=0.56941348, val_MSE_maskV_-1.0=0.69371307, learning_rate=0.001\n", + "Epoch 85/137 - loss=0.61877704, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61527145, MSE_maskV_-1.0=0.61887974, val_loss=0.69359767, val_CC_maskV_-1.0=0.56974262, val_MSE_maskV_-1.0=0.6935395, learning_rate=0.001\n", + "Epoch 99/137 - loss=0.61450702, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61893362, MSE_maskV_-1.0=0.61427164, val_loss=0.68678778, val_CC_maskV_-1.0=0.57536459, val_MSE_maskV_-1.0=0.68665892, learning_rate=0.001\n", + "Epoch 113/137 - loss=0.61189598, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6205616, MSE_maskV_-1.0=0.61514509, val_loss=0.6849407, val_CC_maskV_-1.0=0.57758605, val_MSE_maskV_-1.0=0.68462479, learning_rate=0.001\n", + "Epoch 127/137 - loss=0.60962945, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6224342, MSE_maskV_-1.0=0.61042958, val_loss=0.68923342, val_CC_maskV_-1.0=0.57460529, val_MSE_maskV_-1.0=0.68866092, learning_rate=0.001\n", + "Epoch 137/137 - loss=0.60793859, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62429357, MSE_maskV_-1.0=0.60763437, val_loss=0.68621242, val_CC_maskV_-1.0=0.57647508, val_MSE_maskV_-1.0=0.68601435, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:27:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 38.84s\n", + "\u001b[32m2025-05-30 15:27:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:28:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 181 (stopped at 196 epochs).\n", + "\u001b[32m2025-05-30 15:28:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/197 - loss=1.2093804, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.14730412, MSE_maskV_-1.0=1.2087452, val_loss=0.98591721, val_CC_maskV_-1.0=0.24421631, val_MSE_maskV_-1.0=0.98345059, learning_rate=0.001\n", + "Epoch 21/197 - loss=0.66997898, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57203102, MSE_maskV_-1.0=0.6700418, val_loss=0.72127587, val_CC_maskV_-1.0=0.54569679, val_MSE_maskV_-1.0=0.72002947, learning_rate=0.001\n", + "Epoch 41/197 - loss=0.63982821, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59759772, MSE_maskV_-1.0=0.64024723, val_loss=0.70793873, val_CC_maskV_-1.0=0.55909652, val_MSE_maskV_-1.0=0.70684606, learning_rate=0.001\n", + "Epoch 61/197 - loss=0.62871206, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60819048, MSE_maskV_-1.0=0.62866181, val_loss=0.69685888, val_CC_maskV_-1.0=0.56900692, val_MSE_maskV_-1.0=0.69579786, learning_rate=0.001\n", + "Epoch 81/197 - loss=0.6205731, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61459535, MSE_maskV_-1.0=0.62068534, val_loss=0.69289422, val_CC_maskV_-1.0=0.5717206, val_MSE_maskV_-1.0=0.69222963, learning_rate=0.001\n", + "Epoch 101/197 - loss=0.61527753, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61929286, MSE_maskV_-1.0=0.61469656, val_loss=0.68884039, val_CC_maskV_-1.0=0.57535851, val_MSE_maskV_-1.0=0.6880517, learning_rate=0.001\n", + "Epoch 121/197 - loss=0.61172068, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62085646, MSE_maskV_-1.0=0.611417, val_loss=0.68256718, val_CC_maskV_-1.0=0.58058697, val_MSE_maskV_-1.0=0.68188781, learning_rate=0.001\n", + "Epoch 141/197 - loss=0.60729468, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62578851, MSE_maskV_-1.0=0.60830504, val_loss=0.68139786, val_CC_maskV_-1.0=0.58075964, val_MSE_maskV_-1.0=0.68120462, learning_rate=0.001\n", + "Epoch 161/197 - loss=0.60329789, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62826097, MSE_maskV_-1.0=0.60361302, val_loss=0.67685264, val_CC_maskV_-1.0=0.58414316, val_MSE_maskV_-1.0=0.67663252, learning_rate=0.001\n", + "Epoch 181/197 - loss=0.60151196, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62884641, MSE_maskV_-1.0=0.60160512, val_loss=0.67486787, val_CC_maskV_-1.0=0.58496016, val_MSE_maskV_-1.0=0.67541033, learning_rate=0.001\n", + "Epoch 197/197 - loss=0.5994904, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63025337, MSE_maskV_-1.0=0.59991878, val_loss=0.67886192, val_CC_maskV_-1.0=0.58263314, val_MSE_maskV_-1.0=0.67921591, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:28:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 50.71s\n", + "\u001b[32m2025-05-30 15:28:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.67486787)\n", + "\u001b[32m2025-05-30 15:28:45\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 764us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:28:45\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.597, R2_maskV_-1.0=0.403, CC_maskV_-1.0=0.635\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 748us/step\n", + "51/51 [==============================] - 0s 781us/step\n", + "84/84 [==============================] - 0s 742us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:28:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_ACy1HL64U_ErSV16\" (8/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_ACy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:28:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_KCz1HL64U_ErSV16\" (9/16)\n", + "\u001b[32m2025-05-30 15:28:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:28:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:28:46\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:28:46\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:28:46\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:28:46\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:28:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:29:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 131 (stopped at 146 epochs).\n", + "\u001b[32m2025-05-30 15:29:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/147 - loss=rnn_1step_loss=1.0015404, rnn_1step_R2_maskV_-1.0=-0.014210634, rnn_1step_CC_maskV_-1.0=0.020419322, rnn_1step_MSE_maskV_-1.0=1.0015405, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92292923, val_rnn_1step_R2_maskV_-1.0=-0.064340636, val_rnn_1step_CC_maskV_-1.0=0.26188529, learning_rate=0.001\n", + "Epoch 16/147 - loss=rnn_1step_loss=0.7388857, rnn_1step_R2_maskV_-1.0=0.24851006, rnn_1step_CC_maskV_-1.0=0.51813734, rnn_1step_MSE_maskV_-1.0=0.73888576, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.69594175, val_rnn_1step_R2_maskV_-1.0=0.18947668, val_rnn_1step_CC_maskV_-1.0=0.49796319, learning_rate=0.001\n", + "Epoch 31/147 - loss=rnn_1step_loss=0.56850761, rnn_1step_R2_maskV_-1.0=0.41945714, rnn_1step_CC_maskV_-1.0=0.65818954, rnn_1step_MSE_maskV_-1.0=0.56850767, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63071209, val_rnn_1step_R2_maskV_-1.0=0.26482731, val_rnn_1step_CC_maskV_-1.0=0.57781047, learning_rate=0.001\n", + "Epoch 46/147 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.44246712, rnn_1step_R2_maskV_-1.0=0.54898131, rnn_1step_CC_maskV_-1.0=0.74788243, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5707891, val_rnn_1step_R2_maskV_-1.0=0.33887732, val_rnn_1step_CC_maskV_-1.0=0.63211775, learning_rate=0.001\n", + "Epoch 61/147 - loss=rnn_1step_loss=0.33055687, rnn_1step_R2_maskV_-1.0=0.66471642, rnn_1step_CC_maskV_-1.0=0.8181383, rnn_1step_MSE_maskV_-1.0=0.33055684, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52424443, val_rnn_1step_R2_maskV_-1.0=0.38947275, val_rnn_1step_CC_maskV_-1.0=0.67921233, learning_rate=0.001\n", + "Epoch 76/147 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27591279, rnn_1step_R2_maskV_-1.0=0.72066373, rnn_1step_CC_maskV_-1.0=0.85096836, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50456452, val_rnn_1step_R2_maskV_-1.0=0.4094941, val_rnn_1step_CC_maskV_-1.0=0.69757205, learning_rate=0.001\n", + "Epoch 91/147 - loss=rnn_1step_loss=0.24402745, rnn_1step_R2_maskV_-1.0=0.75280786, rnn_1step_CC_maskV_-1.0=0.86946607, rnn_1step_MSE_maskV_-1.0=0.24402747, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50229317, val_rnn_1step_R2_maskV_-1.0=0.41117328, val_rnn_1step_CC_maskV_-1.0=0.7026431, learning_rate=0.001\n", + "Epoch 106/147 - loss=rnn_1step_loss=0.22240692, rnn_1step_R2_maskV_-1.0=0.77446955, rnn_1step_CC_maskV_-1.0=0.88186181, rnn_1step_MSE_maskV_-1.0=0.22240689, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49511147, val_rnn_1step_R2_maskV_-1.0=0.41862527, val_rnn_1step_CC_maskV_-1.0=0.70905137, learning_rate=0.001\n", + "Epoch 121/147 - loss=rnn_1step_loss=0.20361435, rnn_1step_R2_maskV_-1.0=0.79312432, rnn_1step_CC_maskV_-1.0=0.8922953, rnn_1step_MSE_maskV_-1.0=0.20361434, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48711276, val_rnn_1step_R2_maskV_-1.0=0.42830226, val_rnn_1step_CC_maskV_-1.0=0.7151202, learning_rate=0.001\n", + "Epoch 136/147 - loss=rnn_1step_loss=0.19088973, rnn_1step_R2_maskV_-1.0=0.80598778, rnn_1step_CC_maskV_-1.0=0.8993355, rnn_1step_MSE_maskV_-1.0=0.19088975, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48245263, val_rnn_1step_R2_maskV_-1.0=0.43333691, val_rnn_1step_CC_maskV_-1.0=0.71758342, learning_rate=0.001\n", + "Epoch 147/147 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.18620016, rnn_1step_R2_maskV_-1.0=0.81058109, rnn_1step_CC_maskV_-1.0=0.90205938, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48801634, val_rnn_1step_R2_maskV_-1.0=0.42765903, val_rnn_1step_CC_maskV_-1.0=0.71775728, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:29:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 16.14s\n", + "\u001b[32m2025-05-30 15:29:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:29:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 76 (stopped at 91 epochs).\n", + "\u001b[32m2025-05-30 15:29:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.001413, rnn_1_1step_R2_maskV_-1.0=-0.014087647, rnn_1_1step_CC_maskV_-1.0=0.075221121, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92277747, val_rnn_1_1step_R2_maskV_-1.0=-0.064150244, val_rnn_1_1step_CC_maskV_-1.0=0.26063839, learning_rate=0.001\n", + "Epoch 11/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.8543672, rnn_1_1step_R2_maskV_-1.0=0.13149376, rnn_1_1step_CC_maskV_-1.0=0.3854658, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.79973125, val_rnn_1_1step_R2_maskV_-1.0=0.074568942, val_rnn_1_1step_CC_maskV_-1.0=0.38473704, learning_rate=0.001\n", + "Epoch 21/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.69808, rnn_1_1step_R2_maskV_-1.0=0.28921545, rnn_1_1step_CC_maskV_-1.0=0.55463779, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.72189683, val_rnn_1_1step_R2_maskV_-1.0=0.16166233, val_rnn_1_1step_CC_maskV_-1.0=0.48705274, learning_rate=0.001\n", + "Epoch 31/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.5807485, rnn_1_1step_R2_maskV_-1.0=0.40809977, rnn_1_1step_CC_maskV_-1.0=0.64993936, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63103724, val_rnn_1_1step_R2_maskV_-1.0=0.26384601, val_rnn_1_1step_CC_maskV_-1.0=0.56872743, learning_rate=0.001\n", + "Epoch 41/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.50752997, rnn_1_1step_R2_maskV_-1.0=0.48257586, rnn_1_1step_CC_maskV_-1.0=0.70163244, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60402197, val_rnn_1_1step_R2_maskV_-1.0=0.29642111, val_rnn_1_1step_CC_maskV_-1.0=0.60182023, learning_rate=0.001\n", + "Epoch 51/92 - loss=rnn_1_1step_loss=0.43746176, rnn_1_1step_R2_maskV_-1.0=0.55493283, rnn_1_1step_CC_maskV_-1.0=0.7496376, rnn_1_1step_MSE_maskV_-1.0=0.43746179, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56751472, val_rnn_1_1step_R2_maskV_-1.0=0.33777112, val_rnn_1_1step_CC_maskV_-1.0=0.63594007, learning_rate=0.001\n", + "Epoch 61/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36892077, rnn_1_1step_R2_maskV_-1.0=0.62676209, rnn_1_1step_CC_maskV_-1.0=0.79431105, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54603201, val_rnn_1_1step_R2_maskV_-1.0=0.35874641, val_rnn_1_1step_CC_maskV_-1.0=0.65419507, learning_rate=0.001\n", + "Epoch 71/92 - loss=rnn_1_1step_loss=0.32658964, rnn_1_1step_R2_maskV_-1.0=0.67029858, rnn_1_1step_CC_maskV_-1.0=0.82136786, rnn_1_1step_MSE_maskV_-1.0=0.32658967, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53980035, val_rnn_1_1step_R2_maskV_-1.0=0.36781883, val_rnn_1_1step_CC_maskV_-1.0=0.66210097, learning_rate=0.001\n", + "Epoch 81/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.28334895, rnn_1_1step_R2_maskV_-1.0=0.71397817, rnn_1_1step_CC_maskV_-1.0=0.84649074, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52073818, val_rnn_1_1step_R2_maskV_-1.0=0.38905549, val_rnn_1_1step_CC_maskV_-1.0=0.68006265, learning_rate=0.001\n", + "Epoch 91/92 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.26207921, rnn_1_1step_R2_maskV_-1.0=0.73536074, rnn_1_1step_CC_maskV_-1.0=0.8588419, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52234453, val_rnn_1_1step_R2_maskV_-1.0=0.38764319, val_rnn_1_1step_CC_maskV_-1.0=0.68327445, learning_rate=0.001\n", + "Epoch 92/92 - loss=rnn_1_1step_loss=0.26008597, rnn_1_1step_R2_maskV_-1.0=0.73737276, rnn_1_1step_CC_maskV_-1.0=0.86020398, rnn_1_1step_MSE_maskV_-1.0=0.26008594, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52696157, val_rnn_1_1step_R2_maskV_-1.0=0.3822245, val_rnn_1_1step_CC_maskV_-1.0=0.68148893, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:29:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.99s\n", + "\u001b[32m2025-05-30 15:29:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.47053507)\n", + "\u001b[32m2025-05-30 15:29:15\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.174, R2_maskV_-1.0=0.826, CC_maskV_-1.0=0.909\n", + "\u001b[32m2025-05-30 15:29:15\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.421, R2_maskV_-1.0=0.514, CC_maskV_-1.0=0.758\n", + "\u001b[32m2025-05-30 15:29:15\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:29:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:30:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 298 (stopped at 313 epochs).\n", + "\u001b[32m2025-05-30 15:30:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/314 - loss=3.0884793, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0348185, MSE_maskV_-1.0=3.0827625, val_loss=1.2842004, val_CC_maskV_-1.0=0.046644192, val_MSE_maskV_-1.0=1.2825257, learning_rate=0.001\n", + "Epoch 33/314 - loss=0.86025369, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37612292, MSE_maskV_-1.0=0.8596285, val_loss=0.90031815, val_CC_maskV_-1.0=0.36554685, val_MSE_maskV_-1.0=0.89707714, learning_rate=0.001\n", + "Epoch 65/314 - loss=0.83710927, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40582827, MSE_maskV_-1.0=0.83615649, val_loss=0.87843794, val_CC_maskV_-1.0=0.39249668, val_MSE_maskV_-1.0=0.87577403, learning_rate=0.001\n", + "Epoch 97/314 - loss=0.82502133, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42053416, MSE_maskV_-1.0=0.82459724, val_loss=0.86521727, val_CC_maskV_-1.0=0.40947565, val_MSE_maskV_-1.0=0.86239499, learning_rate=0.001\n", + "Epoch 129/314 - loss=0.81651831, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43022043, MSE_maskV_-1.0=0.8164525, val_loss=0.85940498, val_CC_maskV_-1.0=0.41642472, val_MSE_maskV_-1.0=0.85638624, learning_rate=0.001\n", + "Epoch 161/314 - loss=0.80993915, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43789011, MSE_maskV_-1.0=0.81015819, val_loss=0.85375321, val_CC_maskV_-1.0=0.42312112, val_MSE_maskV_-1.0=0.85082108, learning_rate=0.001\n", + "Epoch 193/314 - loss=0.80476564, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44471613, MSE_maskV_-1.0=0.80462146, val_loss=0.84906644, val_CC_maskV_-1.0=0.42903429, val_MSE_maskV_-1.0=0.8461163, learning_rate=0.001\n", + "Epoch 225/314 - loss=0.80039364, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44897741, MSE_maskV_-1.0=0.80035347, val_loss=0.84680706, val_CC_maskV_-1.0=0.42934668, val_MSE_maskV_-1.0=0.84420669, learning_rate=0.001\n", + "Epoch 257/314 - loss=0.79718268, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45233768, MSE_maskV_-1.0=0.79692864, val_loss=0.84396416, val_CC_maskV_-1.0=0.43326557, val_MSE_maskV_-1.0=0.84152722, learning_rate=0.001\n", + "Epoch 289/314 - loss=0.79408646, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45574272, MSE_maskV_-1.0=0.79368979, val_loss=0.83959526, val_CC_maskV_-1.0=0.43886846, val_MSE_maskV_-1.0=0.83637732, learning_rate=0.001\n", + "Epoch 314/314 - loss=0.79280919, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45736593, MSE_maskV_-1.0=0.79251963, val_loss=0.83858335, val_CC_maskV_-1.0=0.43985251, val_MSE_maskV_-1.0=0.83551019, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:30:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 74.34s\n", + "\u001b[32m2025-05-30 15:30:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:31:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 298 (stopped at 313 epochs).\n", + "\u001b[32m2025-05-30 15:31:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/314 - loss=3.231925, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.03113866, MSE_maskV_-1.0=3.2258556, val_loss=1.2403473, val_CC_maskV_-1.0=0.090021983, val_MSE_maskV_-1.0=1.2357347, learning_rate=0.001\n", + "Epoch 33/314 - loss=0.85928154, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37747326, MSE_maskV_-1.0=0.85864693, val_loss=0.9023419, val_CC_maskV_-1.0=0.3634136, val_MSE_maskV_-1.0=0.89892673, learning_rate=0.001\n", + "Epoch 65/314 - loss=0.8383559, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40417442, MSE_maskV_-1.0=0.83740562, val_loss=0.88170701, val_CC_maskV_-1.0=0.3883082, val_MSE_maskV_-1.0=0.87901843, learning_rate=0.001\n", + "Epoch 97/314 - loss=0.8266443, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41843984, MSE_maskV_-1.0=0.82622075, val_loss=0.86860454, val_CC_maskV_-1.0=0.40528119, val_MSE_maskV_-1.0=0.8658101, learning_rate=0.001\n", + "Epoch 129/314 - loss=0.8181622, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42823213, MSE_maskV_-1.0=0.81810075, val_loss=0.86227334, val_CC_maskV_-1.0=0.41289568, val_MSE_maskV_-1.0=0.85935068, learning_rate=0.001\n", + "Epoch 161/314 - loss=0.81147003, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43606493, MSE_maskV_-1.0=0.81168741, val_loss=0.85633117, val_CC_maskV_-1.0=0.42010611, val_MSE_maskV_-1.0=0.85348928, learning_rate=0.001\n", + "Epoch 193/314 - loss=0.80617869, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44311649, MSE_maskV_-1.0=0.80602169, val_loss=0.8514508, val_CC_maskV_-1.0=0.426245, val_MSE_maskV_-1.0=0.84863108, learning_rate=0.001\n", + "Epoch 225/314 - loss=0.80164677, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44755656, MSE_maskV_-1.0=0.80160171, val_loss=0.84907025, val_CC_maskV_-1.0=0.42680269, val_MSE_maskV_-1.0=0.84657121, learning_rate=0.001\n", + "Epoch 257/314 - loss=0.79830456, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45110899, MSE_maskV_-1.0=0.79804432, val_loss=0.84592605, val_CC_maskV_-1.0=0.43100914, val_MSE_maskV_-1.0=0.84365648, learning_rate=0.001\n", + "Epoch 289/314 - loss=0.79509658, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45465988, MSE_maskV_-1.0=0.79470658, val_loss=0.84135145, val_CC_maskV_-1.0=0.43682566, val_MSE_maskV_-1.0=0.83829898, learning_rate=0.001\n", + "Epoch 314/314 - loss=0.7937389, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45638597, MSE_maskV_-1.0=0.79343951, val_loss=0.84005255, val_CC_maskV_-1.0=0.43818054, val_MSE_maskV_-1.0=0.83715433, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:31:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 74.07s\n", + "\u001b[32m2025-05-30 15:31:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.83573991)\n", + "\u001b[32m2025-05-30 15:31:43\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 753us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:31:44\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.794, R2_maskV_-1.0=0.205, CC_maskV_-1.0=0.455\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 683us/step\n", + "51/51 [==============================] - 0s 739us/step\n", + "84/84 [==============================] - 0s 722us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:31:44\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_KCz1HL64U_ErSV16\" (9/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_KCz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:31:44\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_KCy1HL64U_ErSV16\" (10/16)\n", + "\u001b[32m2025-05-30 15:31:44\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:31:44\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:31:44\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:31:45\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:31:45\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:31:45\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:31:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:31:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 66 (stopped at 81 epochs).\n", + "\u001b[32m2025-05-30 15:31:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/82 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0009466, rnn_1step_R2_maskV_-1.0=-0.013590697, rnn_1step_CC_maskV_-1.0=0.086122759, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.9218626, val_rnn_1step_R2_maskV_-1.0=-0.063165992, val_rnn_1step_CC_maskV_-1.0=0.26059639, learning_rate=0.001\n", + "Epoch 10/82 - loss=rnn_1step_loss=0.88070732, rnn_1step_R2_maskV_-1.0=0.10853587, rnn_1step_CC_maskV_-1.0=0.40893611, rnn_1step_MSE_maskV_-1.0=0.88070738, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.81387424, val_rnn_1step_R2_maskV_-1.0=0.057330921, val_rnn_1step_CC_maskV_-1.0=0.36826399, learning_rate=0.001\n", + "Epoch 19/82 - loss=rnn_1step_loss=0.63116163, rnn_1step_R2_maskV_-1.0=0.36145946, rnn_1step_CC_maskV_-1.0=0.60748833, rnn_1step_MSE_maskV_-1.0=0.63116157, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64082927, val_rnn_1step_R2_maskV_-1.0=0.25032645, val_rnn_1step_CC_maskV_-1.0=0.55765647, learning_rate=0.001\n", + "Epoch 28/82 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.45205247, rnn_1step_R2_maskV_-1.0=0.54137135, rnn_1step_CC_maskV_-1.0=0.74009877, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52536511, val_rnn_1step_R2_maskV_-1.0=0.38570607, val_rnn_1step_CC_maskV_-1.0=0.66700381, learning_rate=0.001\n", + "Epoch 37/82 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38601235, rnn_1step_R2_maskV_-1.0=0.60853285, rnn_1step_CC_maskV_-1.0=0.78383386, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49715233, val_rnn_1step_R2_maskV_-1.0=0.41765955, val_rnn_1step_CC_maskV_-1.0=0.69160032, learning_rate=0.001\n", + "Epoch 46/82 - loss=rnn_1step_loss=0.35086346, rnn_1step_R2_maskV_-1.0=0.64421773, rnn_1step_CC_maskV_-1.0=0.80595511, rnn_1step_MSE_maskV_-1.0=0.35086343, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.483219, val_rnn_1step_R2_maskV_-1.0=0.43462351, val_rnn_1step_CC_maskV_-1.0=0.70207852, learning_rate=0.001\n", + "Epoch 55/82 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31975579, rnn_1step_R2_maskV_-1.0=0.67612684, rnn_1step_CC_maskV_-1.0=0.82484448, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46660098, val_rnn_1step_R2_maskV_-1.0=0.45400649, val_rnn_1step_CC_maskV_-1.0=0.71558374, learning_rate=0.001\n", + "Epoch 64/82 - loss=rnn_1step_loss=0.29284075, rnn_1step_R2_maskV_-1.0=0.70364714, rnn_1step_CC_maskV_-1.0=0.84078139, rnn_1step_MSE_maskV_-1.0=0.29284078, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45950142, val_rnn_1step_R2_maskV_-1.0=0.46188036, val_rnn_1step_CC_maskV_-1.0=0.72398287, learning_rate=0.001\n", + "Epoch 73/82 - loss=rnn_1step_loss=0.27286807, rnn_1step_R2_maskV_-1.0=0.72391832, rnn_1step_CC_maskV_-1.0=0.85248584, rnn_1step_MSE_maskV_-1.0=0.2728681, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46088946, val_rnn_1step_R2_maskV_-1.0=0.46002483, val_rnn_1step_CC_maskV_-1.0=0.72590089, learning_rate=0.001\n", + "Epoch 82/82 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.25833523, rnn_1step_R2_maskV_-1.0=0.73863757, rnn_1step_CC_maskV_-1.0=0.86095995, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46369791, val_rnn_1step_R2_maskV_-1.0=0.45664504, val_rnn_1step_CC_maskV_-1.0=0.72581929, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:31:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 9.42s\n", + "\u001b[32m2025-05-30 15:31:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:32:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 98 (stopped at 113 epochs).\n", + "\u001b[32m2025-05-30 15:32:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/114 - loss=rnn_1_1step_loss=1.0004476, rnn_1_1step_R2_maskV_-1.0=-0.013076071, rnn_1_1step_CC_maskV_-1.0=0.10349718, rnn_1_1step_MSE_maskV_-1.0=1.0004478, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.9205184, val_rnn_1_1step_R2_maskV_-1.0=-0.061548486, val_rnn_1_1step_CC_maskV_-1.0=0.3018145, learning_rate=0.001\n", + "Epoch 13/114 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.7466259, rnn_1_1step_R2_maskV_-1.0=0.24077198, rnn_1_1step_CC_maskV_-1.0=0.5089705, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.71318156, val_rnn_1_1step_R2_maskV_-1.0=0.17117912, val_rnn_1_1step_CC_maskV_-1.0=0.48519158, learning_rate=0.001\n", + "Epoch 25/114 - loss=rnn_1_1step_loss=0.58286637, rnn_1_1step_R2_maskV_-1.0=0.40461022, rnn_1_1step_CC_maskV_-1.0=0.64776719, rnn_1_1step_MSE_maskV_-1.0=0.58286631, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63556856, val_rnn_1_1step_R2_maskV_-1.0=0.25955296, val_rnn_1_1step_CC_maskV_-1.0=0.57260376, learning_rate=0.001\n", + "Epoch 37/114 - loss=rnn_1_1step_loss=0.47819564, rnn_1_1step_R2_maskV_-1.0=0.5122292, rnn_1_1step_CC_maskV_-1.0=0.72264075, rnn_1_1step_MSE_maskV_-1.0=0.47819561, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58661425, val_rnn_1_1step_R2_maskV_-1.0=0.31907457, val_rnn_1_1step_CC_maskV_-1.0=0.6205731, learning_rate=0.001\n", + "Epoch 49/114 - loss=rnn_1_1step_loss=0.39359999, rnn_1_1step_R2_maskV_-1.0=0.59968579, rnn_1_1step_CC_maskV_-1.0=0.77889812, rnn_1_1step_MSE_maskV_-1.0=0.39359996, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54303831, val_rnn_1_1step_R2_maskV_-1.0=0.36950547, val_rnn_1_1step_CC_maskV_-1.0=0.65834135, learning_rate=0.001\n", + "Epoch 61/114 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31569251, rnn_1_1step_R2_maskV_-1.0=0.68025041, rnn_1_1step_CC_maskV_-1.0=0.82746547, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49232683, val_rnn_1_1step_R2_maskV_-1.0=0.42415452, val_rnn_1_1step_CC_maskV_-1.0=0.70100695, learning_rate=0.001\n", + "Epoch 73/114 - loss=rnn_1_1step_loss=0.27654064, rnn_1_1step_R2_maskV_-1.0=0.72025812, rnn_1_1step_CC_maskV_-1.0=0.85061276, rnn_1_1step_MSE_maskV_-1.0=0.27654067, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48299766, val_rnn_1_1step_R2_maskV_-1.0=0.43385255, val_rnn_1_1step_CC_maskV_-1.0=0.71298224, learning_rate=0.001\n", + "Epoch 85/114 - loss=rnn_1_1step_loss=0.25379881, rnn_1_1step_R2_maskV_-1.0=0.74324512, rnn_1_1step_CC_maskV_-1.0=0.86378264, rnn_1_1step_MSE_maskV_-1.0=0.25379884, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48196983, val_rnn_1_1step_R2_maskV_-1.0=0.43442217, val_rnn_1_1step_CC_maskV_-1.0=0.71636873, learning_rate=0.001\n", + "Epoch 97/114 - loss=rnn_1_1step_loss=0.24363156, rnn_1_1step_R2_maskV_-1.0=0.75346637, rnn_1_1step_CC_maskV_-1.0=0.86961198, rnn_1_1step_MSE_maskV_-1.0=0.24363154, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48016644, val_rnn_1_1step_R2_maskV_-1.0=0.43607864, val_rnn_1_1step_CC_maskV_-1.0=0.72040904, learning_rate=0.001\n", + "Epoch 109/114 - loss=rnn_1_1step_loss=0.22558598, rnn_1_1step_R2_maskV_-1.0=0.77175069, rnn_1_1step_CC_maskV_-1.0=0.87981272, rnn_1_1step_MSE_maskV_-1.0=0.225586, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48506334, val_rnn_1_1step_R2_maskV_-1.0=0.42991024, val_rnn_1_1step_CC_maskV_-1.0=0.7171672, learning_rate=0.001\n", + "Epoch 114/114 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.22194378, rnn_1_1step_R2_maskV_-1.0=0.77535868, rnn_1_1step_CC_maskV_-1.0=0.88178921, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48369613, val_rnn_1_1step_R2_maskV_-1.0=0.43170458, val_rnn_1_1step_CC_maskV_-1.0=0.7175777, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:32:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.15s\n", + "\u001b[32m2025-05-30 15:32:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.45929411)\n", + "\u001b[32m2025-05-30 15:32:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.253, R2_maskV_-1.0=0.747, CC_maskV_-1.0=0.864\n", + "\u001b[32m2025-05-30 15:32:08\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.422, R2_maskV_-1.0=0.517, CC_maskV_-1.0=0.752\n", + "\u001b[32m2025-05-30 15:32:08\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:32:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:32:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 135 (stopped at 150 epochs).\n", + "\u001b[32m2025-05-30 15:32:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/151 - loss=1.1021615, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.12039649, MSE_maskV_-1.0=1.1020826, val_loss=1.0002854, val_CC_maskV_-1.0=0.19324921, val_MSE_maskV_-1.0=0.9971751, learning_rate=0.001\n", + "Epoch 17/151 - loss=0.85138643, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38771087, MSE_maskV_-1.0=0.85118788, val_loss=0.89921021, val_CC_maskV_-1.0=0.36270714, val_MSE_maskV_-1.0=0.89859468, learning_rate=0.001\n", + "Epoch 33/151 - loss=0.81232119, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43472913, MSE_maskV_-1.0=0.8118903, val_loss=0.86197406, val_CC_maskV_-1.0=0.40832216, val_MSE_maskV_-1.0=0.86135125, learning_rate=0.001\n", + "Epoch 49/151 - loss=0.78822225, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46051151, MSE_maskV_-1.0=0.78809333, val_loss=0.84503818, val_CC_maskV_-1.0=0.42724684, val_MSE_maskV_-1.0=0.84503764, learning_rate=0.001\n", + "Epoch 65/151 - loss=0.77476943, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4737635, MSE_maskV_-1.0=0.77406335, val_loss=0.82735682, val_CC_maskV_-1.0=0.4442564, val_MSE_maskV_-1.0=0.82733613, learning_rate=0.001\n", + "Epoch 81/151 - loss=0.76440114, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48535922, MSE_maskV_-1.0=0.76487732, val_loss=0.82055831, val_CC_maskV_-1.0=0.45178431, val_MSE_maskV_-1.0=0.82026583, learning_rate=0.001\n", + "Epoch 97/151 - loss=0.75803077, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49130622, MSE_maskV_-1.0=0.75757802, val_loss=0.81480515, val_CC_maskV_-1.0=0.45920882, val_MSE_maskV_-1.0=0.81277066, learning_rate=0.001\n", + "Epoch 113/151 - loss=0.75332034, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49515533, MSE_maskV_-1.0=0.75716561, val_loss=0.81403565, val_CC_maskV_-1.0=0.46067968, val_MSE_maskV_-1.0=0.81204081, learning_rate=0.001\n", + "Epoch 129/151 - loss=0.74880409, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49967808, MSE_maskV_-1.0=0.74883413, val_loss=0.80736184, val_CC_maskV_-1.0=0.46631876, val_MSE_maskV_-1.0=0.80570954, learning_rate=0.001\n", + "Epoch 145/151 - loss=0.74487621, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50328469, MSE_maskV_-1.0=0.74523574, val_loss=0.80991441, val_CC_maskV_-1.0=0.46498612, val_MSE_maskV_-1.0=0.80801725, learning_rate=0.001\n", + "Epoch 151/151 - loss=0.74352372, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5055415, MSE_maskV_-1.0=0.74341875, val_loss=0.80812418, val_CC_maskV_-1.0=0.46600953, val_MSE_maskV_-1.0=0.80667973, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:32:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 39.19s\n", + "\u001b[32m2025-05-30 15:32:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:33:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 181 (stopped at 196 epochs).\n", + "\u001b[32m2025-05-30 15:33:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/197 - loss=1.0816319, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.12696369, MSE_maskV_-1.0=1.0815306, val_loss=0.99855936, val_CC_maskV_-1.0=0.1996776, val_MSE_maskV_-1.0=0.99504435, learning_rate=0.001\n", + "Epoch 21/197 - loss=0.8377285, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40394893, MSE_maskV_-1.0=0.83757925, val_loss=0.88789803, val_CC_maskV_-1.0=0.37803748, val_MSE_maskV_-1.0=0.8866964, learning_rate=0.001\n", + "Epoch 41/197 - loss=0.79968703, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44794837, MSE_maskV_-1.0=0.80016011, val_loss=0.85568243, val_CC_maskV_-1.0=0.41597518, val_MSE_maskV_-1.0=0.85485113, learning_rate=0.001\n", + "Epoch 61/197 - loss=0.78164756, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46785274, MSE_maskV_-1.0=0.78177387, val_loss=0.83798516, val_CC_maskV_-1.0=0.43570787, val_MSE_maskV_-1.0=0.83727998, learning_rate=0.001\n", + "Epoch 81/197 - loss=0.77009898, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47947162, MSE_maskV_-1.0=0.7705273, val_loss=0.83402115, val_CC_maskV_-1.0=0.43884957, val_MSE_maskV_-1.0=0.83332789, learning_rate=0.001\n", + "Epoch 101/197 - loss=0.76168966, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48778936, MSE_maskV_-1.0=0.76093519, val_loss=0.82444394, val_CC_maskV_-1.0=0.45090598, val_MSE_maskV_-1.0=0.82236594, learning_rate=0.001\n", + "Epoch 121/197 - loss=0.75686574, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49185511, MSE_maskV_-1.0=0.75679904, val_loss=0.82117403, val_CC_maskV_-1.0=0.45437402, val_MSE_maskV_-1.0=0.81910205, learning_rate=0.001\n", + "Epoch 141/197 - loss=0.75048578, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49933684, MSE_maskV_-1.0=0.75222743, val_loss=0.82100648, val_CC_maskV_-1.0=0.4554652, val_MSE_maskV_-1.0=0.81821382, learning_rate=0.001\n", + "Epoch 161/197 - loss=0.74811316, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50069594, MSE_maskV_-1.0=0.74839026, val_loss=0.81718385, val_CC_maskV_-1.0=0.45807019, val_MSE_maskV_-1.0=0.81543142, learning_rate=0.001\n", + "Epoch 181/197 - loss=0.74415296, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.504682, MSE_maskV_-1.0=0.74403995, val_loss=0.8088271, val_CC_maskV_-1.0=0.46671453, val_MSE_maskV_-1.0=0.80667859, learning_rate=0.001\n", + "Epoch 197/197 - loss=0.74134994, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50727534, MSE_maskV_-1.0=0.74167866, val_loss=0.81156164, val_CC_maskV_-1.0=0.46451211, val_MSE_maskV_-1.0=0.80929857, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:33:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 50.48s\n", + "\u001b[32m2025-05-30 15:33:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.80350447)\n", + "\u001b[32m2025-05-30 15:33:37\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 766us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:33:38\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.744, R2_maskV_-1.0=0.257, CC_maskV_-1.0=0.507\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 750us/step\n", + "51/51 [==============================] - 0s 761us/step\n", + "84/84 [==============================] - 0s 754us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:33:38\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_KCy1HL64U_ErSV16\" (10/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_KCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:33:38\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_CzCy1HL64U_ErSV16\" (11/16)\n", + "\u001b[32m2025-05-30 15:33:38\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_CzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:33:38\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:33:38\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:33:39\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:33:39\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:33:39\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:33:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:34:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 284 (stopped at 299 epochs).\n", + "\u001b[32m2025-05-30 15:34:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/300 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0012504, rnn_1step_R2_maskV_-1.0=-0.013891235, rnn_1step_CC_maskV_-1.0=0.042356301, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92185861, val_rnn_1step_R2_maskV_-1.0=-0.063104719, val_rnn_1step_CC_maskV_-1.0=0.25593922, learning_rate=0.001\n", + "Epoch 31/300 - loss=rnn_1step_loss=0.54510337, rnn_1step_R2_maskV_-1.0=0.44450498, rnn_1step_CC_maskV_-1.0=0.67430747, rnn_1step_MSE_maskV_-1.0=0.54510331, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61885184, val_rnn_1step_R2_maskV_-1.0=0.28095195, val_rnn_1step_CC_maskV_-1.0=0.59453082, learning_rate=0.001\n", + "Epoch 61/300 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38970098, rnn_1step_R2_maskV_-1.0=0.60338384, rnn_1step_CC_maskV_-1.0=0.78123027, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51636523, val_rnn_1step_R2_maskV_-1.0=0.3948673, val_rnn_1step_CC_maskV_-1.0=0.68110621, learning_rate=0.001\n", + "Epoch 91/300 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34167877, rnn_1step_R2_maskV_-1.0=0.65264463, rnn_1step_CC_maskV_-1.0=0.81121141, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47813794, val_rnn_1step_R2_maskV_-1.0=0.43798989, val_rnn_1step_CC_maskV_-1.0=0.71300268, learning_rate=0.001\n", + "Epoch 121/300 - loss=rnn_1step_loss=0.32685062, rnn_1step_R2_maskV_-1.0=0.66761684, rnn_1step_CC_maskV_-1.0=0.82023805, rnn_1step_MSE_maskV_-1.0=0.32685059, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47439227, val_rnn_1step_R2_maskV_-1.0=0.44283041, val_rnn_1step_CC_maskV_-1.0=0.71771473, learning_rate=0.001\n", + "Epoch 151/300 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31830901, rnn_1step_R2_maskV_-1.0=0.67622101, rnn_1step_CC_maskV_-1.0=0.82536876, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47150764, val_rnn_1step_R2_maskV_-1.0=0.44673616, val_rnn_1step_CC_maskV_-1.0=0.72049624, learning_rate=0.001\n", + "Epoch 181/300 - loss=rnn_1step_loss=0.31172982, rnn_1step_R2_maskV_-1.0=0.68293512, rnn_1step_CC_maskV_-1.0=0.8293485, rnn_1step_MSE_maskV_-1.0=0.31172979, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47408807, val_rnn_1step_R2_maskV_-1.0=0.44375995, val_rnn_1step_CC_maskV_-1.0=0.72016805, learning_rate=0.001\n", + "Epoch 211/300 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30645752, rnn_1step_R2_maskV_-1.0=0.68828529, rnn_1step_CC_maskV_-1.0=0.83244228, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47094074, val_rnn_1step_R2_maskV_-1.0=0.44775581, val_rnn_1step_CC_maskV_-1.0=0.72203338, learning_rate=0.001\n", + "Epoch 241/300 - loss=rnn_1step_loss=0.3007687, rnn_1step_R2_maskV_-1.0=0.69398773, rnn_1step_CC_maskV_-1.0=0.8360647, rnn_1step_MSE_maskV_-1.0=0.30076873, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47035751, val_rnn_1step_R2_maskV_-1.0=0.44859451, val_rnn_1step_CC_maskV_-1.0=0.72289819, learning_rate=0.001\n", + "Epoch 271/300 - loss=rnn_1step_loss=0.29739162, rnn_1step_R2_maskV_-1.0=0.6973058, rnn_1step_CC_maskV_-1.0=0.83812416, rnn_1step_MSE_maskV_-1.0=0.29739159, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46694815, val_rnn_1step_R2_maskV_-1.0=0.45298615, val_rnn_1step_CC_maskV_-1.0=0.7243129, learning_rate=0.001\n", + "Epoch 300/300 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29465792, rnn_1step_R2_maskV_-1.0=0.70019865, rnn_1step_CC_maskV_-1.0=0.83953393, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47017619, val_rnn_1step_R2_maskV_-1.0=0.4497301, val_rnn_1step_CC_maskV_-1.0=0.72348195, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:34:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 28.99s\n", + "\u001b[32m2025-05-30 15:34:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:34:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 132 (stopped at 147 epochs).\n", + "\u001b[32m2025-05-30 15:34:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/148 - loss=rnn_1_1step_loss=1.0010725, rnn_1_1step_R2_maskV_-1.0=-0.013691094, rnn_1_1step_CC_maskV_-1.0=0.076016665, rnn_1_1step_MSE_maskV_-1.0=1.0010726, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92124349, val_rnn_1_1step_R2_maskV_-1.0=-0.062437087, val_rnn_1_1step_CC_maskV_-1.0=0.27748057, learning_rate=0.001\n", + "Epoch 16/148 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.7605021, rnn_1_1step_R2_maskV_-1.0=0.22998439, rnn_1_1step_CC_maskV_-1.0=0.49353188, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.73356938, val_rnn_1_1step_R2_maskV_-1.0=0.14110531, val_rnn_1_1step_CC_maskV_-1.0=0.46232063, learning_rate=0.001\n", + "Epoch 31/148 - loss=rnn_1_1step_loss=0.54675716, rnn_1_1step_R2_maskV_-1.0=0.44485074, rnn_1_1step_CC_maskV_-1.0=0.67231876, rnn_1_1step_MSE_maskV_-1.0=0.54675722, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6214481, val_rnn_1_1step_R2_maskV_-1.0=0.27727264, val_rnn_1_1step_CC_maskV_-1.0=0.59928602, learning_rate=0.001\n", + "Epoch 46/148 - loss=rnn_1_1step_loss=0.44805661, rnn_1_1step_R2_maskV_-1.0=0.54522216, rnn_1_1step_CC_maskV_-1.0=0.74286819, rnn_1_1step_MSE_maskV_-1.0=0.44805664, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54981881, val_rnn_1_1step_R2_maskV_-1.0=0.3539637, val_rnn_1_1step_CC_maskV_-1.0=0.65796298, learning_rate=0.001\n", + "Epoch 61/148 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41005206, rnn_1_1step_R2_maskV_-1.0=0.58314294, rnn_1_1step_CC_maskV_-1.0=0.76829594, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5288853, val_rnn_1_1step_R2_maskV_-1.0=0.37904462, val_rnn_1_1step_CC_maskV_-1.0=0.67178255, learning_rate=0.001\n", + "Epoch 76/148 - loss=rnn_1_1step_loss=0.38697791, rnn_1_1step_R2_maskV_-1.0=0.60625142, rnn_1_1step_CC_maskV_-1.0=0.7832942, rnn_1_1step_MSE_maskV_-1.0=0.38697794, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51694924, val_rnn_1_1step_R2_maskV_-1.0=0.39356458, val_rnn_1_1step_CC_maskV_-1.0=0.67916155, learning_rate=0.001\n", + "Epoch 91/148 - loss=rnn_1_1step_loss=0.36704159, rnn_1_1step_R2_maskV_-1.0=0.62658179, rnn_1_1step_CC_maskV_-1.0=0.79579574, rnn_1_1step_MSE_maskV_-1.0=0.36704156, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50346327, val_rnn_1_1step_R2_maskV_-1.0=0.4090074, val_rnn_1_1step_CC_maskV_-1.0=0.68979025, learning_rate=0.001\n", + "Epoch 106/148 - loss=rnn_1_1step_loss=0.34748492, rnn_1_1step_R2_maskV_-1.0=0.646613, rnn_1_1step_CC_maskV_-1.0=0.80772388, rnn_1_1step_MSE_maskV_-1.0=0.34748495, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48690107, val_rnn_1_1step_R2_maskV_-1.0=0.42815948, val_rnn_1_1step_CC_maskV_-1.0=0.70457917, learning_rate=0.001\n", + "Epoch 121/148 - loss=rnn_1_1step_loss=0.33497873, rnn_1_1step_R2_maskV_-1.0=0.65932745, rnn_1_1step_CC_maskV_-1.0=0.81530035, rnn_1_1step_MSE_maskV_-1.0=0.33497876, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47869182, val_rnn_1_1step_R2_maskV_-1.0=0.43801469, val_rnn_1_1step_CC_maskV_-1.0=0.71293235, learning_rate=0.001\n", + "Epoch 136/148 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.3279548, rnn_1_1step_R2_maskV_-1.0=0.66645378, rnn_1_1step_CC_maskV_-1.0=0.81954241, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47715273, val_rnn_1_1step_R2_maskV_-1.0=0.43995088, val_rnn_1_1step_CC_maskV_-1.0=0.71536642, learning_rate=0.001\n", + "Epoch 148/148 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32424128, rnn_1_1step_R2_maskV_-1.0=0.67023814, rnn_1_1step_CC_maskV_-1.0=0.82175064, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47811094, val_rnn_1_1step_R2_maskV_-1.0=0.43876296, val_rnn_1_1step_CC_maskV_-1.0=0.7161985, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:34:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.47s\n", + "\u001b[32m2025-05-30 15:34:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.46318352)\n", + "\u001b[32m2025-05-30 15:34:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.273, R2_maskV_-1.0=0.726, CC_maskV_-1.0=0.853\n", + "\u001b[32m2025-05-30 15:34:25\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.426, R2_maskV_-1.0=0.511, CC_maskV_-1.0=0.756\n", + "\u001b[32m2025-05-30 15:34:25\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:34:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:34:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 90 (stopped at 105 epochs).\n", + "\u001b[32m2025-05-30 15:34:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/106 - loss=3.0610747, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.053766679, MSE_maskV_-1.0=3.0549669, val_loss=1.2144171, val_CC_maskV_-1.0=0.11256123, val_MSE_maskV_-1.0=1.2120975, learning_rate=0.001\n", + "Epoch 12/106 - loss=0.79134989, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4560267, MSE_maskV_-1.0=0.79177254, val_loss=0.83292252, val_CC_maskV_-1.0=0.44178227, val_MSE_maskV_-1.0=0.82994342, learning_rate=0.001\n", + "Epoch 23/106 - loss=0.71407771, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53329027, MSE_maskV_-1.0=0.71401, val_loss=0.76397556, val_CC_maskV_-1.0=0.50874102, val_MSE_maskV_-1.0=0.76174319, learning_rate=0.001\n", + "Epoch 34/106 - loss=0.66976553, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57337505, MSE_maskV_-1.0=0.66969472, val_loss=0.71773785, val_CC_maskV_-1.0=0.54915112, val_MSE_maskV_-1.0=0.715864, learning_rate=0.001\n", + "Epoch 45/106 - loss=0.65313089, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58734363, MSE_maskV_-1.0=0.65278572, val_loss=0.69678622, val_CC_maskV_-1.0=0.56573784, val_MSE_maskV_-1.0=0.69538313, learning_rate=0.001\n", + "Epoch 56/106 - loss=0.64257026, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59550792, MSE_maskV_-1.0=0.64291161, val_loss=0.685574, val_CC_maskV_-1.0=0.57610846, val_MSE_maskV_-1.0=0.68442506, learning_rate=0.001\n", + "Epoch 67/106 - loss=0.63568103, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60142815, MSE_maskV_-1.0=0.63549626, val_loss=0.68410373, val_CC_maskV_-1.0=0.57681179, val_MSE_maskV_-1.0=0.68286461, learning_rate=0.001\n", + "Epoch 78/106 - loss=0.63248932, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60317802, MSE_maskV_-1.0=0.63237852, val_loss=0.67930174, val_CC_maskV_-1.0=0.57943624, val_MSE_maskV_-1.0=0.67831367, learning_rate=0.001\n", + "Epoch 89/106 - loss=0.62830722, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60741729, MSE_maskV_-1.0=0.62862909, val_loss=0.67914182, val_CC_maskV_-1.0=0.58034724, val_MSE_maskV_-1.0=0.67846709, learning_rate=0.001\n", + "Epoch 100/106 - loss=0.62487358, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60865623, MSE_maskV_-1.0=0.62488663, val_loss=0.67633063, val_CC_maskV_-1.0=0.5823217, val_MSE_maskV_-1.0=0.67526251, learning_rate=0.001\n", + "Epoch 106/106 - loss=0.62434071, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61053288, MSE_maskV_-1.0=0.62426102, val_loss=0.67592114, val_CC_maskV_-1.0=0.58335197, val_MSE_maskV_-1.0=0.67474979, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:34:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 27.61s\n", + "\u001b[32m2025-05-30 15:34:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:35:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 91 (stopped at 106 epochs).\n", + "\u001b[32m2025-05-30 15:35:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/107 - loss=3.6536708, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0514194, MSE_maskV_-1.0=3.6460679, val_loss=1.2602336, val_CC_maskV_-1.0=0.089666866, val_MSE_maskV_-1.0=1.256888, learning_rate=0.001\n", + "Epoch 12/107 - loss=0.80402488, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44229621, MSE_maskV_-1.0=0.80456799, val_loss=0.85745227, val_CC_maskV_-1.0=0.41737407, val_MSE_maskV_-1.0=0.85544419, learning_rate=0.001\n", + "Epoch 23/107 - loss=0.73025876, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5183506, MSE_maskV_-1.0=0.73026115, val_loss=0.78249961, val_CC_maskV_-1.0=0.49311742, val_MSE_maskV_-1.0=0.78012502, learning_rate=0.001\n", + "Epoch 34/107 - loss=0.68694341, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55832899, MSE_maskV_-1.0=0.6868012, val_loss=0.74000376, val_CC_maskV_-1.0=0.53182584, val_MSE_maskV_-1.0=0.73773021, learning_rate=0.001\n", + "Epoch 45/107 - loss=0.66302729, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57880747, MSE_maskV_-1.0=0.66271883, val_loss=0.71000397, val_CC_maskV_-1.0=0.55657375, val_MSE_maskV_-1.0=0.70815593, learning_rate=0.001\n", + "Epoch 56/107 - loss=0.64682525, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59200478, MSE_maskV_-1.0=0.64713126, val_loss=0.69476277, val_CC_maskV_-1.0=0.56918508, val_MSE_maskV_-1.0=0.69349313, learning_rate=0.001\n", + "Epoch 67/107 - loss=0.63718814, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59994471, MSE_maskV_-1.0=0.63709688, val_loss=0.69895434, val_CC_maskV_-1.0=0.56608295, val_MSE_maskV_-1.0=0.69776499, learning_rate=0.001\n", + "Epoch 78/107 - loss=0.63227981, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60308623, MSE_maskV_-1.0=0.63220274, val_loss=0.69238806, val_CC_maskV_-1.0=0.57019377, val_MSE_maskV_-1.0=0.69171906, learning_rate=0.001\n", + "Epoch 89/107 - loss=0.62753206, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6082319, MSE_maskV_-1.0=0.62779492, val_loss=0.68295276, val_CC_maskV_-1.0=0.5777989, val_MSE_maskV_-1.0=0.68263942, learning_rate=0.001\n", + "Epoch 100/107 - loss=0.6239869, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60947442, MSE_maskV_-1.0=0.62396824, val_loss=0.68108177, val_CC_maskV_-1.0=0.5779829, val_MSE_maskV_-1.0=0.68075925, learning_rate=0.001\n", + "Epoch 107/107 - loss=0.62238979, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61212736, MSE_maskV_-1.0=0.62215531, val_loss=0.67890352, val_CC_maskV_-1.0=0.57976359, val_MSE_maskV_-1.0=0.67898315, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:35:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 27.50s\n", + "\u001b[32m2025-05-30 15:35:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.67279977)\n", + "\u001b[32m2025-05-30 15:35:20\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 777us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:35:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.626, R2_maskV_-1.0=0.376, CC_maskV_-1.0=0.612\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 785us/step\n", + "51/51 [==============================] - 0s 747us/step\n", + "84/84 [==============================] - 0s 699us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:35:21\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_CzCy1HL64U_ErSV16\" (11/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_CzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:35:21\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_uAKCz1HL64U_ErSV16\" (12/16)\n", + "\u001b[32m2025-05-30 15:35:21\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:35:21\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:35:21\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:35:21\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:35:21\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:35:21\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:35:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:35:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 66 (stopped at 81 epochs).\n", + "\u001b[32m2025-05-30 15:35:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/82 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0013533, rnn_1step_R2_maskV_-1.0=-0.014019411, rnn_1step_CC_maskV_-1.0=0.088738054, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92269492, val_rnn_1step_R2_maskV_-1.0=-0.064084291, val_rnn_1step_CC_maskV_-1.0=0.27870086, learning_rate=0.001\n", + "Epoch 10/82 - loss=rnn_1step_loss=0.87305427, rnn_1step_R2_maskV_-1.0=0.11511122, rnn_1step_CC_maskV_-1.0=0.36191967, rnn_1step_MSE_maskV_-1.0=0.87305433, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.7864728, val_rnn_1step_R2_maskV_-1.0=0.087884977, val_rnn_1step_CC_maskV_-1.0=0.39646366, learning_rate=0.001\n", + "Epoch 19/82 - loss=rnn_1step_loss=0.72978359, rnn_1step_R2_maskV_-1.0=0.25703889, rnn_1step_CC_maskV_-1.0=0.5253517, rnn_1step_MSE_maskV_-1.0=0.72978365, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.73588687, val_rnn_1step_R2_maskV_-1.0=0.14751782, val_rnn_1step_CC_maskV_-1.0=0.45398018, learning_rate=0.001\n", + "Epoch 28/82 - loss=rnn_1step_loss=0.60816175, rnn_1step_R2_maskV_-1.0=0.37854952, rnn_1step_CC_maskV_-1.0=0.62696707, rnn_1step_MSE_maskV_-1.0=0.60816181, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.65639186, val_rnn_1step_R2_maskV_-1.0=0.23927198, val_rnn_1step_CC_maskV_-1.0=0.5437668, learning_rate=0.001\n", + "Epoch 37/82 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.52556163, rnn_1step_R2_maskV_-1.0=0.46320513, rnn_1step_CC_maskV_-1.0=0.68930411, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60444444, val_rnn_1step_R2_maskV_-1.0=0.29834473, val_rnn_1step_CC_maskV_-1.0=0.59586942, learning_rate=0.001\n", + "Epoch 46/82 - loss=rnn_1step_loss=0.4586333, rnn_1step_R2_maskV_-1.0=0.5323621, rnn_1step_CC_maskV_-1.0=0.73570299, rnn_1step_MSE_maskV_-1.0=0.45863327, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55742139, val_rnn_1step_R2_maskV_-1.0=0.34805405, val_rnn_1step_CC_maskV_-1.0=0.63659567, learning_rate=0.001\n", + "Epoch 55/82 - loss=rnn_1step_loss=0.4194673, rnn_1step_R2_maskV_-1.0=0.5725075, rnn_1step_CC_maskV_-1.0=0.76253605, rnn_1step_MSE_maskV_-1.0=0.41946733, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52687782, val_rnn_1step_R2_maskV_-1.0=0.38211906, val_rnn_1step_CC_maskV_-1.0=0.65879154, learning_rate=0.001\n", + "Epoch 64/82 - loss=rnn_1step_loss=0.37380698, rnn_1step_R2_maskV_-1.0=0.61930239, rnn_1step_CC_maskV_-1.0=0.7918216, rnn_1step_MSE_maskV_-1.0=0.37380695, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50344253, val_rnn_1step_R2_maskV_-1.0=0.4086329, val_rnn_1step_CC_maskV_-1.0=0.67948562, learning_rate=0.001\n", + "Epoch 73/82 - loss=rnn_1step_loss=0.33311722, rnn_1step_R2_maskV_-1.0=0.66130573, rnn_1step_CC_maskV_-1.0=0.81612003, rnn_1step_MSE_maskV_-1.0=0.33311725, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5160234, val_rnn_1step_R2_maskV_-1.0=0.39398015, val_rnn_1step_CC_maskV_-1.0=0.67777538, learning_rate=0.001\n", + "Epoch 82/82 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31857693, rnn_1step_R2_maskV_-1.0=0.67668307, rnn_1step_CC_maskV_-1.0=0.82626379, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50624925, val_rnn_1step_R2_maskV_-1.0=0.40612847, val_rnn_1step_CC_maskV_-1.0=0.67990911, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:35:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.96s\n", + "\u001b[32m2025-05-30 15:35:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:35:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 139 (stopped at 154 epochs).\n", + "\u001b[32m2025-05-30 15:35:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/155 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0015157, rnn_1_1step_R2_maskV_-1.0=-0.014185507, rnn_1_1step_CC_maskV_-1.0=0.032488365, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92285204, val_rnn_1_1step_R2_maskV_-1.0=-0.064251631, val_rnn_1_1step_CC_maskV_-1.0=0.23766018, learning_rate=0.001\n", + "Epoch 17/155 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.66874903, rnn_1_1step_R2_maskV_-1.0=0.31814045, rnn_1_1step_CC_maskV_-1.0=0.57624221, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.67654389, val_rnn_1_1step_R2_maskV_-1.0=0.21055408, val_rnn_1_1step_CC_maskV_-1.0=0.52809036, learning_rate=0.001\n", + "Epoch 33/155 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.53649306, rnn_1_1step_R2_maskV_-1.0=0.4515951, rnn_1_1step_CC_maskV_-1.0=0.68185782, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61412209, val_rnn_1_1step_R2_maskV_-1.0=0.28596306, val_rnn_1_1step_CC_maskV_-1.0=0.58360636, learning_rate=0.001\n", + "Epoch 49/155 - loss=rnn_1_1step_loss=0.41813827, rnn_1_1step_R2_maskV_-1.0=0.57236385, rnn_1_1step_CC_maskV_-1.0=0.76348329, rnn_1_1step_MSE_maskV_-1.0=0.4181383, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55420905, val_rnn_1_1step_R2_maskV_-1.0=0.35483706, val_rnn_1_1step_CC_maskV_-1.0=0.64311099, learning_rate=0.001\n", + "Epoch 65/155 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33261251, rnn_1_1step_R2_maskV_-1.0=0.66113496, rnn_1_1step_CC_maskV_-1.0=0.81699657, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49747744, val_rnn_1_1step_R2_maskV_-1.0=0.41944593, val_rnn_1_1step_CC_maskV_-1.0=0.69378453, learning_rate=0.001\n", + "Epoch 81/155 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.28195438, rnn_1_1step_R2_maskV_-1.0=0.71335208, rnn_1_1step_CC_maskV_-1.0=0.84707505, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49195293, val_rnn_1_1step_R2_maskV_-1.0=0.42825255, val_rnn_1_1step_CC_maskV_-1.0=0.69556224, learning_rate=0.001\n", + "Epoch 97/155 - loss=rnn_1_1step_loss=0.25724503, rnn_1_1step_R2_maskV_-1.0=0.73800969, rnn_1_1step_CC_maskV_-1.0=0.86126471, rnn_1_1step_MSE_maskV_-1.0=0.257245, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48242199, val_rnn_1_1step_R2_maskV_-1.0=0.43839255, val_rnn_1_1step_CC_maskV_-1.0=0.70372909, learning_rate=0.001\n", + "Epoch 113/155 - loss=rnn_1_1step_loss=0.23628967, rnn_1_1step_R2_maskV_-1.0=0.75946987, rnn_1_1step_CC_maskV_-1.0=0.87389141, rnn_1_1step_MSE_maskV_-1.0=0.23628965, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46902117, val_rnn_1_1step_R2_maskV_-1.0=0.45315391, val_rnn_1_1step_CC_maskV_-1.0=0.71269554, learning_rate=0.001\n", + "Epoch 129/155 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.22399193, rnn_1_1step_R2_maskV_-1.0=0.77182496, rnn_1_1step_CC_maskV_-1.0=0.88111722, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47428691, val_rnn_1_1step_R2_maskV_-1.0=0.4468053, val_rnn_1_1step_CC_maskV_-1.0=0.71066582, learning_rate=0.001\n", + "Epoch 145/155 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.21341074, rnn_1_1step_R2_maskV_-1.0=0.7825498, rnn_1_1step_CC_maskV_-1.0=0.88650918, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.494975, val_rnn_1_1step_R2_maskV_-1.0=0.42239231, val_rnn_1_1step_CC_maskV_-1.0=0.702591, learning_rate=0.001\n", + "Epoch 155/155 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.20303316, rnn_1_1step_R2_maskV_-1.0=0.79337502, rnn_1_1step_CC_maskV_-1.0=0.89317119, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45657039, val_rnn_1_1step_R2_maskV_-1.0=0.46538767, val_rnn_1_1step_CC_maskV_-1.0=0.72501206, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:35:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 18.18s\n", + "\u001b[32m2025-05-30 15:35:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.4496713)\n", + "\u001b[32m2025-05-30 15:35:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.196, R2_maskV_-1.0=0.804, CC_maskV_-1.0=0.897\n", + "\u001b[32m2025-05-30 15:35:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.428, R2_maskV_-1.0=0.51, CC_maskV_-1.0=0.748\n", + "\u001b[32m2025-05-30 15:35:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:35:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:36:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 211 (stopped at 226 epochs).\n", + "\u001b[32m2025-05-30 15:36:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/227 - loss=1.7339003, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.037270069, MSE_maskV_-1.0=1.7321094, val_loss=1.0946664, val_CC_maskV_-1.0=0.088219523, val_MSE_maskV_-1.0=1.0897858, learning_rate=0.001\n", + "Epoch 24/227 - loss=0.88417673, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34787112, MSE_maskV_-1.0=0.88372463, val_loss=0.91663587, val_CC_maskV_-1.0=0.34763318, val_MSE_maskV_-1.0=0.91446829, learning_rate=0.001\n", + "Epoch 47/227 - loss=0.85293311, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38948146, MSE_maskV_-1.0=0.85287744, val_loss=0.88575256, val_CC_maskV_-1.0=0.38648978, val_MSE_maskV_-1.0=0.88353264, learning_rate=0.001\n", + "Epoch 70/227 - loss=0.83661461, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40872777, MSE_maskV_-1.0=0.83626646, val_loss=0.87206584, val_CC_maskV_-1.0=0.40141284, val_MSE_maskV_-1.0=0.8698625, learning_rate=0.001\n", + "Epoch 93/227 - loss=0.82612365, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4211044, MSE_maskV_-1.0=0.82535267, val_loss=0.86084592, val_CC_maskV_-1.0=0.41180366, val_MSE_maskV_-1.0=0.85892487, learning_rate=0.001\n", + "Epoch 116/227 - loss=0.81886524, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4293088, MSE_maskV_-1.0=0.81814152, val_loss=0.85568124, val_CC_maskV_-1.0=0.4180069, val_MSE_maskV_-1.0=0.85333771, learning_rate=0.001\n", + "Epoch 139/227 - loss=0.81340069, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43457922, MSE_maskV_-1.0=0.81314808, val_loss=0.84945434, val_CC_maskV_-1.0=0.42501611, val_MSE_maskV_-1.0=0.84687549, learning_rate=0.001\n", + "Epoch 162/227 - loss=0.80925357, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43888187, MSE_maskV_-1.0=0.80884266, val_loss=0.84797984, val_CC_maskV_-1.0=0.42523438, val_MSE_maskV_-1.0=0.84547657, learning_rate=0.001\n", + "Epoch 185/227 - loss=0.80549359, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44377232, MSE_maskV_-1.0=0.80586982, val_loss=0.84198481, val_CC_maskV_-1.0=0.43163082, val_MSE_maskV_-1.0=0.83958054, learning_rate=0.001\n", + "Epoch 208/227 - loss=0.80287695, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44614878, MSE_maskV_-1.0=0.80302322, val_loss=0.8407588, val_CC_maskV_-1.0=0.43273103, val_MSE_maskV_-1.0=0.83811033, learning_rate=0.001\n", + "Epoch 227/227 - loss=0.80097789, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4480893, MSE_maskV_-1.0=0.80201834, val_loss=0.83935845, val_CC_maskV_-1.0=0.43463865, val_MSE_maskV_-1.0=0.83642131, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:36:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 54.49s\n", + "\u001b[32m2025-05-30 15:36:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:37:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 211 (stopped at 226 epochs).\n", + "\u001b[32m2025-05-30 15:37:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/227 - loss=1.8828498, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=-0.00034692156, MSE_maskV_-1.0=1.8807718, val_loss=1.1366917, val_CC_maskV_-1.0=0.038280837, val_MSE_maskV_-1.0=1.1356704, learning_rate=0.001\n", + "Epoch 24/227 - loss=0.88246328, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35080072, MSE_maskV_-1.0=0.88199997, val_loss=0.91586798, val_CC_maskV_-1.0=0.34781897, val_MSE_maskV_-1.0=0.91429853, learning_rate=0.001\n", + "Epoch 47/227 - loss=0.85155207, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39140892, MSE_maskV_-1.0=0.85149366, val_loss=0.88534391, val_CC_maskV_-1.0=0.38596994, val_MSE_maskV_-1.0=0.88359046, learning_rate=0.001\n", + "Epoch 70/227 - loss=0.83557582, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40994924, MSE_maskV_-1.0=0.83523947, val_loss=0.87225986, val_CC_maskV_-1.0=0.40029618, val_MSE_maskV_-1.0=0.87042373, learning_rate=0.001\n", + "Epoch 93/227 - loss=0.82532066, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42194256, MSE_maskV_-1.0=0.82457161, val_loss=0.86098158, val_CC_maskV_-1.0=0.41088358, val_MSE_maskV_-1.0=0.85940558, learning_rate=0.001\n", + "Epoch 116/227 - loss=0.81820112, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43002793, MSE_maskV_-1.0=0.81746525, val_loss=0.85602289, val_CC_maskV_-1.0=0.41691452, val_MSE_maskV_-1.0=0.85396934, learning_rate=0.001\n", + "Epoch 139/227 - loss=0.8128345, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43518394, MSE_maskV_-1.0=0.81257355, val_loss=0.84976774, val_CC_maskV_-1.0=0.42406213, val_MSE_maskV_-1.0=0.84745443, learning_rate=0.001\n", + "Epoch 162/227 - loss=0.80875844, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43940082, MSE_maskV_-1.0=0.80835903, val_loss=0.84824556, val_CC_maskV_-1.0=0.42445391, val_MSE_maskV_-1.0=0.84599006, learning_rate=0.001\n", + "Epoch 185/227 - loss=0.80506605, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44428334, MSE_maskV_-1.0=0.80542862, val_loss=0.84214342, val_CC_maskV_-1.0=0.430994, val_MSE_maskV_-1.0=0.83996928, learning_rate=0.001\n", + "Epoch 208/227 - loss=0.80248141, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44655722, MSE_maskV_-1.0=0.80263317, val_loss=0.84093994, val_CC_maskV_-1.0=0.43213975, val_MSE_maskV_-1.0=0.83849502, learning_rate=0.001\n", + "Epoch 227/227 - loss=0.8006162, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44847909, MSE_maskV_-1.0=0.80163378, val_loss=0.8395223, val_CC_maskV_-1.0=0.43407911, val_MSE_maskV_-1.0=0.83679748, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:37:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 53.59s\n", + "\u001b[32m2025-05-30 15:37:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.83735847)\n", + "\u001b[32m2025-05-30 15:37:40\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 714us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:37:40\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.801, R2_maskV_-1.0=0.199, CC_maskV_-1.0=0.448\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 716us/step\n", + "51/51 [==============================] - 0s 763us/step\n", + "84/84 [==============================] - 0s 692us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:37:41\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_uAKCz1HL64U_ErSV16\" (12/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_uAKCz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:37:41\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_uAKCy1HL64U_ErSV16\" (13/16)\n", + "\u001b[32m2025-05-30 15:37:41\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:37:41\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:37:41\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:37:41\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:37:41\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:37:41\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:37:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:37:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 89 (stopped at 104 epochs).\n", + "\u001b[32m2025-05-30 15:37:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0010737, rnn_1step_R2_maskV_-1.0=-0.013736073, rnn_1step_CC_maskV_-1.0=0.062212788, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92259979, val_rnn_1step_R2_maskV_-1.0=-0.063902467, val_rnn_1step_CC_maskV_-1.0=0.16710073, learning_rate=0.001\n", + "Epoch 12/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.80768698, rnn_1step_R2_maskV_-1.0=0.17905755, rnn_1step_CC_maskV_-1.0=0.45502931, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.76772457, val_rnn_1step_R2_maskV_-1.0=0.11419117, val_rnn_1step_CC_maskV_-1.0=0.42447624, learning_rate=0.001\n", + "Epoch 23/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.57992136, rnn_1step_R2_maskV_-1.0=0.40612924, rnn_1step_CC_maskV_-1.0=0.65031058, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63200474, val_rnn_1step_R2_maskV_-1.0=0.26877859, val_rnn_1step_CC_maskV_-1.0=0.57021588, learning_rate=0.001\n", + "Epoch 34/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.45139924, rnn_1step_R2_maskV_-1.0=0.53809237, rnn_1step_CC_maskV_-1.0=0.74177217, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55864364, val_rnn_1step_R2_maskV_-1.0=0.35104981, val_rnn_1step_CC_maskV_-1.0=0.63833523, learning_rate=0.001\n", + "Epoch 45/105 - loss=rnn_1step_loss=0.35446382, rnn_1step_R2_maskV_-1.0=0.63803345, rnn_1step_CC_maskV_-1.0=0.80355132, rnn_1step_MSE_maskV_-1.0=0.35446376, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50362325, val_rnn_1step_R2_maskV_-1.0=0.41491717, val_rnn_1step_CC_maskV_-1.0=0.68511301, learning_rate=0.001\n", + "Epoch 56/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3125135, rnn_1step_R2_maskV_-1.0=0.6814431, rnn_1step_CC_maskV_-1.0=0.82994139, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49495426, val_rnn_1step_R2_maskV_-1.0=0.42576417, val_rnn_1step_CC_maskV_-1.0=0.69753331, learning_rate=0.001\n", + "Epoch 67/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27899987, rnn_1step_R2_maskV_-1.0=0.71634352, rnn_1step_CC_maskV_-1.0=0.84916312, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48307082, val_rnn_1step_R2_maskV_-1.0=0.44049531, val_rnn_1step_CC_maskV_-1.0=0.7068395, learning_rate=0.001\n", + "Epoch 78/105 - loss=rnn_1step_loss=0.25786233, rnn_1step_R2_maskV_-1.0=0.73807216, rnn_1step_CC_maskV_-1.0=0.86141062, rnn_1step_MSE_maskV_-1.0=0.2578623, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48127618, val_rnn_1step_R2_maskV_-1.0=0.4419702, val_rnn_1step_CC_maskV_-1.0=0.71332407, learning_rate=0.001\n", + "Epoch 89/105 - loss=rnn_1step_loss=0.24380946, rnn_1step_R2_maskV_-1.0=0.75232756, rnn_1step_CC_maskV_-1.0=0.86944598, rnn_1step_MSE_maskV_-1.0=0.24380948, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45128012, val_rnn_1step_R2_maskV_-1.0=0.47697046, val_rnn_1step_CC_maskV_-1.0=0.7290045, learning_rate=0.001\n", + "Epoch 100/105 - loss=rnn_1step_loss=0.22754057, rnn_1step_R2_maskV_-1.0=0.76903623, rnn_1step_CC_maskV_-1.0=0.87873721, rnn_1step_MSE_maskV_-1.0=0.22754058, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46467522, val_rnn_1step_R2_maskV_-1.0=0.46190974, val_rnn_1step_CC_maskV_-1.0=0.72497213, learning_rate=0.001\n", + "Epoch 105/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.22366714, rnn_1step_R2_maskV_-1.0=0.7730788, rnn_1step_CC_maskV_-1.0=0.88087046, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46655464, val_rnn_1step_R2_maskV_-1.0=0.45900565, val_rnn_1step_CC_maskV_-1.0=0.72359431, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:37:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.80s\n", + "\u001b[32m2025-05-30 15:37:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:38:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 113 (stopped at 128 epochs).\n", + "\u001b[32m2025-05-30 15:38:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0008062, rnn_1_1step_R2_maskV_-1.0=-0.013454095, rnn_1_1step_CC_maskV_-1.0=0.1023576, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.9209196, val_rnn_1_1step_R2_maskV_-1.0=-0.061885312, val_rnn_1_1step_CC_maskV_-1.0=0.22786377, learning_rate=0.001\n", + "Epoch 14/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.70222211, rnn_1_1step_R2_maskV_-1.0=0.28696999, rnn_1_1step_CC_maskV_-1.0=0.55060738, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.68057281, val_rnn_1_1step_R2_maskV_-1.0=0.20787023, val_rnn_1_1step_CC_maskV_-1.0=0.51323098, learning_rate=0.001\n", + "Epoch 27/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.51648718, rnn_1_1step_R2_maskV_-1.0=0.47311559, rnn_1_1step_CC_maskV_-1.0=0.69528872, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5814271, val_rnn_1_1step_R2_maskV_-1.0=0.3240855, val_rnn_1_1step_CC_maskV_-1.0=0.61671937, learning_rate=0.001\n", + "Epoch 40/129 - loss=rnn_1_1step_loss=0.39644337, rnn_1_1step_R2_maskV_-1.0=0.59587228, rnn_1_1step_CC_maskV_-1.0=0.77672929, rnn_1_1step_MSE_maskV_-1.0=0.39644334, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55050653, val_rnn_1_1step_R2_maskV_-1.0=0.35968971, val_rnn_1_1step_CC_maskV_-1.0=0.65566254, learning_rate=0.001\n", + "Epoch 53/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.29946348, rnn_1_1step_R2_maskV_-1.0=0.69610822, rnn_1_1step_CC_maskV_-1.0=0.83714932, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48872527, val_rnn_1_1step_R2_maskV_-1.0=0.43063417, val_rnn_1_1step_CC_maskV_-1.0=0.70426321, learning_rate=0.001\n", + "Epoch 66/129 - loss=rnn_1_1step_loss=0.26347837, rnn_1_1step_R2_maskV_-1.0=0.73280907, rnn_1_1step_CC_maskV_-1.0=0.85878104, rnn_1_1step_MSE_maskV_-1.0=0.2634784, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47236967, val_rnn_1_1step_R2_maskV_-1.0=0.45087153, val_rnn_1_1step_CC_maskV_-1.0=0.71700132, learning_rate=0.001\n", + "Epoch 79/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.24158037, rnn_1_1step_R2_maskV_-1.0=0.75513846, rnn_1_1step_CC_maskV_-1.0=0.87089974, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46054879, val_rnn_1_1step_R2_maskV_-1.0=0.4650065, val_rnn_1_1step_CC_maskV_-1.0=0.722601, learning_rate=0.001\n", + "Epoch 92/129 - loss=rnn_1_1step_loss=0.22916012, rnn_1_1step_R2_maskV_-1.0=0.76779413, rnn_1_1step_CC_maskV_-1.0=0.87771505, rnn_1_1step_MSE_maskV_-1.0=0.2291601, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46952939, val_rnn_1_1step_R2_maskV_-1.0=0.45526883, val_rnn_1_1step_CC_maskV_-1.0=0.72102576, learning_rate=0.001\n", + "Epoch 105/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.21926385, rnn_1_1step_R2_maskV_-1.0=0.77766359, rnn_1_1step_CC_maskV_-1.0=0.88334978, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.468909, val_rnn_1_1step_R2_maskV_-1.0=0.45597693, val_rnn_1_1step_CC_maskV_-1.0=0.71944994, learning_rate=0.001\n", + "Epoch 118/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.20707493, rnn_1_1step_R2_maskV_-1.0=0.79017031, rnn_1_1step_CC_maskV_-1.0=0.89028728, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46137717, val_rnn_1_1step_R2_maskV_-1.0=0.46449298, val_rnn_1_1step_CC_maskV_-1.0=0.72528273, learning_rate=0.001\n", + "Epoch 129/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.20812754, rnn_1_1step_R2_maskV_-1.0=0.78879982, rnn_1_1step_CC_maskV_-1.0=0.88956004, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45890513, val_rnn_1_1step_R2_maskV_-1.0=0.46804804, val_rnn_1_1step_CC_maskV_-1.0=0.72727579, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:38:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.98s\n", + "\u001b[32m2025-05-30 15:38:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.44725645)\n", + "\u001b[32m2025-05-30 15:38:11\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.194, R2_maskV_-1.0=0.806, CC_maskV_-1.0=0.898\n", + "\u001b[32m2025-05-30 15:38:11\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.412, R2_maskV_-1.0=0.533, CC_maskV_-1.0=0.757\n", + "\u001b[32m2025-05-30 15:38:11\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:38:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:38:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 150 (stopped at 165 epochs).\n", + "\u001b[32m2025-05-30 15:38:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/166 - loss=1.0924062, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.13163228, MSE_maskV_-1.0=1.0922832, val_loss=0.98606175, val_CC_maskV_-1.0=0.21970516, val_MSE_maskV_-1.0=0.98399848, learning_rate=0.001\n", + "Epoch 18/166 - loss=0.81969637, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42720041, MSE_maskV_-1.0=0.82004523, val_loss=0.8762309, val_CC_maskV_-1.0=0.39385003, val_MSE_maskV_-1.0=0.87322801, learning_rate=0.001\n", + "Epoch 35/166 - loss=0.7879225, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46181026, MSE_maskV_-1.0=0.78749955, val_loss=0.85380864, val_CC_maskV_-1.0=0.41869393, val_MSE_maskV_-1.0=0.85119611, learning_rate=0.001\n", + "Epoch 52/166 - loss=0.77129525, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47878367, MSE_maskV_-1.0=0.77253234, val_loss=0.84056145, val_CC_maskV_-1.0=0.43141654, val_MSE_maskV_-1.0=0.83828181, learning_rate=0.001\n", + "Epoch 69/166 - loss=0.76015788, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4897604, MSE_maskV_-1.0=0.75962579, val_loss=0.83024937, val_CC_maskV_-1.0=0.44341177, val_MSE_maskV_-1.0=0.82789546, learning_rate=0.001\n", + "Epoch 86/166 - loss=0.7511695, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49882171, MSE_maskV_-1.0=0.75047922, val_loss=0.8230378, val_CC_maskV_-1.0=0.45056096, val_MSE_maskV_-1.0=0.82050723, learning_rate=0.001\n", + "Epoch 103/166 - loss=0.74491596, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50502837, MSE_maskV_-1.0=0.74483979, val_loss=0.8237378, val_CC_maskV_-1.0=0.45239776, val_MSE_maskV_-1.0=0.82039136, learning_rate=0.001\n", + "Epoch 120/166 - loss=0.74013841, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50906849, MSE_maskV_-1.0=0.73996949, val_loss=0.81914258, val_CC_maskV_-1.0=0.45442188, val_MSE_maskV_-1.0=0.81684881, learning_rate=0.001\n", + "Epoch 137/166 - loss=0.73595417, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51373947, MSE_maskV_-1.0=0.73568898, val_loss=0.81873143, val_CC_maskV_-1.0=0.45577469, val_MSE_maskV_-1.0=0.81559324, learning_rate=0.001\n", + "Epoch 154/166 - loss=0.73248219, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5164535, MSE_maskV_-1.0=0.73241502, val_loss=0.81546015, val_CC_maskV_-1.0=0.45794618, val_MSE_maskV_-1.0=0.81301987, learning_rate=0.001\n", + "Epoch 166/166 - loss=0.72996557, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51930767, MSE_maskV_-1.0=0.7301057, val_loss=0.81078243, val_CC_maskV_-1.0=0.46289974, val_MSE_maskV_-1.0=0.80846483, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:38:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 42.23s\n", + "\u001b[32m2025-05-30 15:38:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:39:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 190 (stopped at 205 epochs).\n", + "\u001b[32m2025-05-30 15:39:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/206 - loss=1.067906, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.14193359, MSE_maskV_-1.0=1.0678943, val_loss=0.9911471, val_CC_maskV_-1.0=0.2086293, val_MSE_maskV_-1.0=0.98865986, learning_rate=0.001\n", + "Epoch 22/206 - loss=0.80930549, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43815571, MSE_maskV_-1.0=0.80893326, val_loss=0.87070727, val_CC_maskV_-1.0=0.40109724, val_MSE_maskV_-1.0=0.86796254, learning_rate=0.001\n", + "Epoch 43/206 - loss=0.77716529, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47252604, MSE_maskV_-1.0=0.77704632, val_loss=0.84997314, val_CC_maskV_-1.0=0.42343771, val_MSE_maskV_-1.0=0.848432, learning_rate=0.001\n", + "Epoch 64/206 - loss=0.76119232, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48896295, MSE_maskV_-1.0=0.76077938, val_loss=0.83375633, val_CC_maskV_-1.0=0.43948507, val_MSE_maskV_-1.0=0.83262968, learning_rate=0.001\n", + "Epoch 85/206 - loss=0.75074458, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49939215, MSE_maskV_-1.0=0.75054657, val_loss=0.82751334, val_CC_maskV_-1.0=0.44697428, val_MSE_maskV_-1.0=0.82619429, learning_rate=0.001\n", + "Epoch 106/206 - loss=0.74260664, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50688583, MSE_maskV_-1.0=0.74249798, val_loss=0.82566249, val_CC_maskV_-1.0=0.45049021, val_MSE_maskV_-1.0=0.82394153, learning_rate=0.001\n", + "Epoch 127/206 - loss=0.73738617, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51114076, MSE_maskV_-1.0=0.73881423, val_loss=0.8216154, val_CC_maskV_-1.0=0.4535144, val_MSE_maskV_-1.0=0.82018751, learning_rate=0.001\n", + "Epoch 148/206 - loss=0.73183316, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5173564, MSE_maskV_-1.0=0.73334056, val_loss=0.81197584, val_CC_maskV_-1.0=0.46456161, val_MSE_maskV_-1.0=0.81022227, learning_rate=0.001\n", + "Epoch 169/206 - loss=0.72786337, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52162886, MSE_maskV_-1.0=0.72748333, val_loss=0.80665928, val_CC_maskV_-1.0=0.47046703, val_MSE_maskV_-1.0=0.80395722, learning_rate=0.001\n", + "Epoch 190/206 - loss=0.72488415, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52345586, MSE_maskV_-1.0=0.72431582, val_loss=0.80420417, val_CC_maskV_-1.0=0.47168672, val_MSE_maskV_-1.0=0.8021276, learning_rate=0.001\n", + "Epoch 206/206 - loss=0.72238654, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5269444, MSE_maskV_-1.0=0.72184789, val_loss=0.80673862, val_CC_maskV_-1.0=0.46995005, val_MSE_maskV_-1.0=0.80461276, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:39:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 51.60s\n", + "\u001b[32m2025-05-30 15:39:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.80420417)\n", + "\u001b[32m2025-05-30 15:39:45\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 785us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:39:45\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.721, R2_maskV_-1.0=0.279, CC_maskV_-1.0=0.529\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 744us/step\n", + "51/51 [==============================] - 0s 784us/step\n", + "84/84 [==============================] - 0s 751us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:39:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_uAKCy1HL64U_ErSV16\" (13/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_uAKCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:39:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_ACzCy1HL64U_ErSV16\" (14/16)\n", + "\u001b[32m2025-05-30 15:39:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:39:46\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:39:46\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:39:46\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:39:46\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:39:46\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:39:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:40:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 97 (stopped at 112 epochs).\n", + "\u001b[32m2025-05-30 15:40:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0012012, rnn_1step_R2_maskV_-1.0=-0.013879873, rnn_1step_CC_maskV_-1.0=0.059492663, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92188221, val_rnn_1step_R2_maskV_-1.0=-0.063057274, val_rnn_1step_CC_maskV_-1.0=0.25272939, learning_rate=0.001\n", + "Epoch 13/113 - loss=rnn_1step_loss=0.78356797, rnn_1step_R2_maskV_-1.0=0.20455648, rnn_1step_CC_maskV_-1.0=0.47451088, rnn_1step_MSE_maskV_-1.0=0.78356802, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.75109392, val_rnn_1step_R2_maskV_-1.0=0.13128138, val_rnn_1step_CC_maskV_-1.0=0.45548561, learning_rate=0.001\n", + "Epoch 25/113 - loss=rnn_1step_loss=0.56960696, rnn_1step_R2_maskV_-1.0=0.41983312, rnn_1step_CC_maskV_-1.0=0.65703654, rnn_1step_MSE_maskV_-1.0=0.5696069, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61345202, val_rnn_1step_R2_maskV_-1.0=0.28677073, val_rnn_1step_CC_maskV_-1.0=0.58659047, learning_rate=0.001\n", + "Epoch 37/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.49776313, rnn_1step_R2_maskV_-1.0=0.4924674, rnn_1step_CC_maskV_-1.0=0.70882386, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59797221, val_rnn_1step_R2_maskV_-1.0=0.30516207, val_rnn_1step_CC_maskV_-1.0=0.60864466, learning_rate=0.001\n", + "Epoch 49/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.45055202, rnn_1step_R2_maskV_-1.0=0.54074931, rnn_1step_CC_maskV_-1.0=0.7418524, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57060748, val_rnn_1step_R2_maskV_-1.0=0.33781651, val_rnn_1step_CC_maskV_-1.0=0.63394189, learning_rate=0.001\n", + "Epoch 61/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4161779, rnn_1step_R2_maskV_-1.0=0.57628083, rnn_1step_CC_maskV_-1.0=0.76506156, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54317576, val_rnn_1step_R2_maskV_-1.0=0.37012658, val_rnn_1step_CC_maskV_-1.0=0.65286565, learning_rate=0.001\n", + "Epoch 73/113 - loss=rnn_1step_loss=0.39316747, rnn_1step_R2_maskV_-1.0=0.60006833, rnn_1step_CC_maskV_-1.0=0.78009617, rnn_1step_MSE_maskV_-1.0=0.39316744, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53362155, val_rnn_1step_R2_maskV_-1.0=0.38132805, val_rnn_1step_CC_maskV_-1.0=0.66115671, learning_rate=0.001\n", + "Epoch 85/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37269172, rnn_1step_R2_maskV_-1.0=0.62080204, rnn_1step_CC_maskV_-1.0=0.79300123, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51729017, val_rnn_1step_R2_maskV_-1.0=0.39832139, val_rnn_1step_CC_maskV_-1.0=0.67426682, learning_rate=0.001\n", + "Epoch 97/113 - loss=rnn_1step_loss=0.35364994, rnn_1step_R2_maskV_-1.0=0.64012861, rnn_1step_CC_maskV_-1.0=0.80468476, rnn_1step_MSE_maskV_-1.0=0.35364997, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50923151, val_rnn_1step_R2_maskV_-1.0=0.40600738, val_rnn_1step_CC_maskV_-1.0=0.68153089, learning_rate=0.001\n", + "Epoch 109/113 - loss=rnn_1step_loss=0.33940253, rnn_1step_R2_maskV_-1.0=0.65484905, rnn_1step_CC_maskV_-1.0=0.81300896, rnn_1step_MSE_maskV_-1.0=0.3394025, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52363735, val_rnn_1step_R2_maskV_-1.0=0.38876247, val_rnn_1step_CC_maskV_-1.0=0.67814475, learning_rate=0.001\n", + "Epoch 113/113 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38183856, rnn_1step_R2_maskV_-1.0=0.61261821, rnn_1step_CC_maskV_-1.0=0.78941, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52677995, val_rnn_1step_R2_maskV_-1.0=0.38374531, val_rnn_1step_CC_maskV_-1.0=0.66804212, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:40:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 13.95s\n", + "\u001b[32m2025-05-30 15:40:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:40:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 184 (stopped at 199 epochs).\n", + "\u001b[32m2025-05-30 15:40:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/200 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0013049, rnn_1_1step_R2_maskV_-1.0=-0.013955969, rnn_1_1step_CC_maskV_-1.0=0.044945441, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92188859, val_rnn_1_1step_R2_maskV_-1.0=-0.063139647, val_rnn_1_1step_CC_maskV_-1.0=0.25032592, learning_rate=0.001\n", + "Epoch 21/200 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.62897688, rnn_1_1step_R2_maskV_-1.0=0.35948926, rnn_1_1step_CC_maskV_-1.0=0.60950083, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.66078395, val_rnn_1_1step_R2_maskV_-1.0=0.22982605, val_rnn_1_1step_CC_maskV_-1.0=0.54983842, learning_rate=0.001\n", + "Epoch 41/200 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.48677802, rnn_1_1step_R2_maskV_-1.0=0.50315273, rnn_1_1step_CC_maskV_-1.0=0.71669799, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58583695, val_rnn_1_1step_R2_maskV_-1.0=0.31760606, val_rnn_1_1step_CC_maskV_-1.0=0.62111259, learning_rate=0.001\n", + "Epoch 61/200 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41610742, rnn_1_1step_R2_maskV_-1.0=0.57636833, rnn_1_1step_CC_maskV_-1.0=0.76369178, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54224896, val_rnn_1_1step_R2_maskV_-1.0=0.36400595, val_rnn_1_1step_CC_maskV_-1.0=0.6599471, learning_rate=0.001\n", + "Epoch 81/200 - loss=rnn_1_1step_loss=0.3877728, rnn_1_1step_R2_maskV_-1.0=0.60540885, rnn_1_1step_CC_maskV_-1.0=0.78201646, rnn_1_1step_MSE_maskV_-1.0=0.38777277, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53762573, val_rnn_1_1step_R2_maskV_-1.0=0.36968917, val_rnn_1_1step_CC_maskV_-1.0=0.66416132, learning_rate=0.001\n", + "Epoch 101/200 - loss=rnn_1_1step_loss=0.37202904, rnn_1_1step_R2_maskV_-1.0=0.62140107, rnn_1_1step_CC_maskV_-1.0=0.79246169, rnn_1_1step_MSE_maskV_-1.0=0.37202901, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52372509, val_rnn_1_1step_R2_maskV_-1.0=0.38761529, val_rnn_1_1step_CC_maskV_-1.0=0.66983122, learning_rate=0.001\n", + "Epoch 121/200 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.3563256, rnn_1_1step_R2_maskV_-1.0=0.63742614, rnn_1_1step_CC_maskV_-1.0=0.80335724, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50485033, val_rnn_1_1step_R2_maskV_-1.0=0.41020343, val_rnn_1_1step_CC_maskV_-1.0=0.68023223, learning_rate=0.001\n", + "Epoch 141/200 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.34355286, rnn_1_1step_R2_maskV_-1.0=0.65042478, rnn_1_1step_CC_maskV_-1.0=0.81000674, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50923938, val_rnn_1_1step_R2_maskV_-1.0=0.40501547, val_rnn_1_1step_CC_maskV_-1.0=0.68170786, learning_rate=0.001\n", + "Epoch 161/200 - loss=rnn_1_1step_loss=0.33132544, rnn_1_1step_R2_maskV_-1.0=0.66305006, rnn_1_1step_CC_maskV_-1.0=0.81830484, rnn_1_1step_MSE_maskV_-1.0=0.33132541, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51041955, val_rnn_1_1step_R2_maskV_-1.0=0.40377477, val_rnn_1_1step_CC_maskV_-1.0=0.68591601, learning_rate=0.001\n", + "Epoch 181/200 - loss=rnn_1_1step_loss=0.32712176, rnn_1_1step_R2_maskV_-1.0=0.66740215, rnn_1_1step_CC_maskV_-1.0=0.82189214, rnn_1_1step_MSE_maskV_-1.0=0.32712179, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48356688, val_rnn_1_1step_R2_maskV_-1.0=0.43543389, val_rnn_1_1step_CC_maskV_-1.0=0.69846606, learning_rate=0.001\n", + "Epoch 200/200 - loss=rnn_1_1step_loss=0.31436506, rnn_1_1step_R2_maskV_-1.0=0.68041897, rnn_1_1step_CC_maskV_-1.0=0.8279283, rnn_1_1step_MSE_maskV_-1.0=0.31436509, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48909199, val_rnn_1_1step_R2_maskV_-1.0=0.42805275, val_rnn_1_1step_CC_maskV_-1.0=0.70189112, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:40:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 22.48s\n", + "\u001b[32m2025-05-30 15:40:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.47467861)\n", + "\u001b[32m2025-05-30 15:40:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.294, R2_maskV_-1.0=0.705, CC_maskV_-1.0=0.841\n", + "\u001b[32m2025-05-30 15:40:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.467, R2_maskV_-1.0=0.467, CC_maskV_-1.0=0.717\n", + "\u001b[32m2025-05-30 15:40:24\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:40:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:41:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 144 (stopped at 159 epochs).\n", + "\u001b[32m2025-05-30 15:41:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/160 - loss=1.4345088, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.13380724, MSE_maskV_-1.0=1.4333888, val_loss=0.99307269, val_CC_maskV_-1.0=0.24859063, val_MSE_maskV_-1.0=0.98960406, learning_rate=0.001\n", + "Epoch 17/160 - loss=0.67616338, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56703538, MSE_maskV_-1.0=0.676211, val_loss=0.72072709, val_CC_maskV_-1.0=0.54410821, val_MSE_maskV_-1.0=0.72010893, learning_rate=0.001\n", + "Epoch 33/160 - loss=0.64115655, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59701139, MSE_maskV_-1.0=0.64096683, val_loss=0.68770635, val_CC_maskV_-1.0=0.57310784, val_MSE_maskV_-1.0=0.68683487, learning_rate=0.001\n", + "Epoch 49/160 - loss=0.62686759, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60866725, MSE_maskV_-1.0=0.62680978, val_loss=0.68180007, val_CC_maskV_-1.0=0.57976323, val_MSE_maskV_-1.0=0.68020856, learning_rate=0.001\n", + "Epoch 65/160 - loss=0.61723942, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61552215, MSE_maskV_-1.0=0.61668044, val_loss=0.67055309, val_CC_maskV_-1.0=0.58857143, val_MSE_maskV_-1.0=0.66895258, learning_rate=0.001\n", + "Epoch 81/160 - loss=0.61019194, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62258631, MSE_maskV_-1.0=0.61009997, val_loss=0.66586697, val_CC_maskV_-1.0=0.5920468, val_MSE_maskV_-1.0=0.66444111, learning_rate=0.001\n", + "Epoch 97/160 - loss=0.60537219, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62609547, MSE_maskV_-1.0=0.60512525, val_loss=0.66298223, val_CC_maskV_-1.0=0.59449643, val_MSE_maskV_-1.0=0.66119242, learning_rate=0.001\n", + "Epoch 113/160 - loss=0.60201442, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62825459, MSE_maskV_-1.0=0.60485196, val_loss=0.65999144, val_CC_maskV_-1.0=0.59645659, val_MSE_maskV_-1.0=0.65865529, learning_rate=0.001\n", + "Epoch 129/160 - loss=0.59843522, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63093525, MSE_maskV_-1.0=0.59831685, val_loss=0.66275835, val_CC_maskV_-1.0=0.59383118, val_MSE_maskV_-1.0=0.66104734, learning_rate=0.001\n", + "Epoch 145/160 - loss=0.59583282, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63270909, MSE_maskV_-1.0=0.59620816, val_loss=0.65302128, val_CC_maskV_-1.0=0.60203558, val_MSE_maskV_-1.0=0.65144724, learning_rate=0.001\n", + "Epoch 160/160 - loss=0.59413236, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63509792, MSE_maskV_-1.0=0.59380776, val_loss=0.65412688, val_CC_maskV_-1.0=0.6006881, val_MSE_maskV_-1.0=0.65289992, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:41:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 40.91s\n", + "\u001b[32m2025-05-30 15:41:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:42:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 211 (stopped at 226 epochs).\n", + "\u001b[32m2025-05-30 15:42:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/227 - loss=1.4254894, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.13880877, MSE_maskV_-1.0=1.4242066, val_loss=0.98284209, val_CC_maskV_-1.0=0.26327074, val_MSE_maskV_-1.0=0.97960299, learning_rate=0.001\n", + "Epoch 24/227 - loss=0.66120493, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58026087, MSE_maskV_-1.0=0.66079438, val_loss=0.7140134, val_CC_maskV_-1.0=0.55140179, val_MSE_maskV_-1.0=0.71285743, learning_rate=0.001\n", + "Epoch 47/227 - loss=0.63496518, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6020028, MSE_maskV_-1.0=0.63516527, val_loss=0.68826342, val_CC_maskV_-1.0=0.57357633, val_MSE_maskV_-1.0=0.68732786, learning_rate=0.001\n", + "Epoch 70/227 - loss=0.62148321, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6127876, MSE_maskV_-1.0=0.62120199, val_loss=0.6822145, val_CC_maskV_-1.0=0.57865208, val_MSE_maskV_-1.0=0.68157393, learning_rate=0.001\n", + "Epoch 93/227 - loss=0.61343873, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61978501, MSE_maskV_-1.0=0.61289108, val_loss=0.67337936, val_CC_maskV_-1.0=0.58535451, val_MSE_maskV_-1.0=0.6728375, learning_rate=0.001\n", + "Epoch 116/227 - loss=0.60793567, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62465066, MSE_maskV_-1.0=0.60742569, val_loss=0.67014235, val_CC_maskV_-1.0=0.58773077, val_MSE_maskV_-1.0=0.66986895, learning_rate=0.001\n", + "Epoch 139/227 - loss=0.60415733, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62681758, MSE_maskV_-1.0=0.60407275, val_loss=0.66667175, val_CC_maskV_-1.0=0.59020835, val_MSE_maskV_-1.0=0.66616774, learning_rate=0.001\n", + "Epoch 162/227 - loss=0.6001783, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62990242, MSE_maskV_-1.0=0.60006022, val_loss=0.66827554, val_CC_maskV_-1.0=0.59044093, val_MSE_maskV_-1.0=0.6678071, learning_rate=0.001\n", + "Epoch 185/227 - loss=0.5967114, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63265049, MSE_maskV_-1.0=0.59619439, val_loss=0.66097134, val_CC_maskV_-1.0=0.59520662, val_MSE_maskV_-1.0=0.66049987, learning_rate=0.001\n", + "Epoch 208/227 - loss=0.59450966, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63464248, MSE_maskV_-1.0=0.59467268, val_loss=0.66385543, val_CC_maskV_-1.0=0.59362251, val_MSE_maskV_-1.0=0.66345948, learning_rate=0.001\n", + "Epoch 227/227 - loss=0.59338832, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63562155, MSE_maskV_-1.0=0.59322321, val_loss=0.65919256, val_CC_maskV_-1.0=0.59619749, val_MSE_maskV_-1.0=0.658871, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:42:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 57.08s\n", + "\u001b[32m2025-05-30 15:42:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.65170521)\n", + "\u001b[32m2025-05-30 15:42:02\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 728us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:42:02\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.591, R2_maskV_-1.0=0.41, CC_maskV_-1.0=0.64\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 750us/step\n", + "51/51 [==============================] - 0s 782us/step\n", + "84/84 [==============================] - 0s 708us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:42:03\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_ACzCy1HL64U_ErSV16\" (14/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_ACzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:42:03\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_KCzCy1HL64U_ErSV16\" (15/16)\n", + "\u001b[32m2025-05-30 15:42:03\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:42:03\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:42:03\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:42:03\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:42:03\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:42:03\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:42:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:42:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 126 (stopped at 141 epochs).\n", + "\u001b[32m2025-05-30 15:42:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/142 - loss=rnn_1step_loss=1.0015692, rnn_1step_R2_maskV_-1.0=-0.01424738, rnn_1step_CC_maskV_-1.0=0.023154918, rnn_1step_MSE_maskV_-1.0=1.001569, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92288923, val_rnn_1step_R2_maskV_-1.0=-0.064276233, val_rnn_1step_CC_maskV_-1.0=0.24602415, learning_rate=0.001\n", + "Epoch 16/142 - loss=rnn_1step_loss=0.78023118, rnn_1step_R2_maskV_-1.0=0.2051709, rnn_1step_CC_maskV_-1.0=0.47893852, rnn_1step_MSE_maskV_-1.0=0.78023112, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.74492055, val_rnn_1step_R2_maskV_-1.0=0.14235501, val_rnn_1step_CC_maskV_-1.0=0.43985221, learning_rate=0.001\n", + "Epoch 31/142 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.54989469, rnn_1step_R2_maskV_-1.0=0.43892422, rnn_1step_CC_maskV_-1.0=0.67164516, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60465759, val_rnn_1step_R2_maskV_-1.0=0.29544827, val_rnn_1step_CC_maskV_-1.0=0.60017449, learning_rate=0.001\n", + "Epoch 46/142 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37822446, rnn_1step_R2_maskV_-1.0=0.61553252, rnn_1step_CC_maskV_-1.0=0.78868067, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49203643, val_rnn_1step_R2_maskV_-1.0=0.42408243, val_rnn_1step_CC_maskV_-1.0=0.69811714, learning_rate=0.001\n", + "Epoch 61/142 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29953849, rnn_1step_R2_maskV_-1.0=0.6966036, rnn_1step_CC_maskV_-1.0=0.83707404, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48198164, val_rnn_1step_R2_maskV_-1.0=0.43403429, val_rnn_1step_CC_maskV_-1.0=0.70957381, learning_rate=0.001\n", + "Epoch 76/142 - loss=rnn_1step_loss=0.26157448, rnn_1step_R2_maskV_-1.0=0.73518908, rnn_1step_CC_maskV_-1.0=0.8594138, rnn_1step_MSE_maskV_-1.0=0.26157445, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47608444, val_rnn_1step_R2_maskV_-1.0=0.44115436, val_rnn_1step_CC_maskV_-1.0=0.71719229, learning_rate=0.001\n", + "Epoch 91/142 - loss=rnn_1step_loss=0.23170744, rnn_1step_R2_maskV_-1.0=0.76541543, rnn_1step_CC_maskV_-1.0=0.87687421, rnn_1step_MSE_maskV_-1.0=0.23170742, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4842855, val_rnn_1step_R2_maskV_-1.0=0.43134946, val_rnn_1step_CC_maskV_-1.0=0.71976024, learning_rate=0.001\n", + "Epoch 106/142 - loss=rnn_1step_loss=0.20714784, rnn_1step_R2_maskV_-1.0=0.78994763, rnn_1step_CC_maskV_-1.0=0.89020663, rnn_1step_MSE_maskV_-1.0=0.20714782, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45892689, val_rnn_1step_R2_maskV_-1.0=0.46261448, val_rnn_1step_CC_maskV_-1.0=0.73355281, learning_rate=0.001\n", + "Epoch 121/142 - loss=rnn_1step_loss=0.19316377, rnn_1step_R2_maskV_-1.0=0.80378783, rnn_1step_CC_maskV_-1.0=0.89778739, rnn_1step_MSE_maskV_-1.0=0.19316378, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45301166, val_rnn_1step_R2_maskV_-1.0=0.46926039, val_rnn_1step_CC_maskV_-1.0=0.73923665, learning_rate=0.001\n", + "Epoch 136/142 - loss=rnn_1step_loss=0.17996778, rnn_1step_R2_maskV_-1.0=0.81735224, rnn_1step_CC_maskV_-1.0=0.9054426, rnn_1step_MSE_maskV_-1.0=0.17996779, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47109762, val_rnn_1step_R2_maskV_-1.0=0.44771805, val_rnn_1step_CC_maskV_-1.0=0.73336768, learning_rate=0.001\n", + "Epoch 142/142 - loss=rnn_1step_loss=0.17868841, rnn_1step_R2_maskV_-1.0=0.81859529, rnn_1step_CC_maskV_-1.0=0.90585107, rnn_1step_MSE_maskV_-1.0=0.17868842, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45084032, val_rnn_1step_R2_maskV_-1.0=0.47227985, val_rnn_1step_CC_maskV_-1.0=0.74312645, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:42:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.87s\n", + "\u001b[32m2025-05-30 15:42:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:42:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 115 (stopped at 130 epochs).\n", + "\u001b[32m2025-05-30 15:42:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/131 - loss=rnn_1_1step_loss=1.0014113, rnn_1_1step_R2_maskV_-1.0=-0.014076181, rnn_1_1step_CC_maskV_-1.0=0.06988287, rnn_1_1step_MSE_maskV_-1.0=1.0014112, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92287046, val_rnn_1_1step_R2_maskV_-1.0=-0.064294055, val_rnn_1_1step_CC_maskV_-1.0=0.27384087, learning_rate=0.001\n", + "Epoch 15/131 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.68458444, rnn_1_1step_R2_maskV_-1.0=0.30431032, rnn_1_1step_CC_maskV_-1.0=0.56383622, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.69842434, val_rnn_1_1step_R2_maskV_-1.0=0.18540013, val_rnn_1_1step_CC_maskV_-1.0=0.51019716, learning_rate=0.001\n", + "Epoch 29/131 - loss=rnn_1_1step_loss=0.50462013, rnn_1_1step_R2_maskV_-1.0=0.48530257, rnn_1_1step_CC_maskV_-1.0=0.70371807, rnn_1_1step_MSE_maskV_-1.0=0.50462019, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58431202, val_rnn_1_1step_R2_maskV_-1.0=0.32196432, val_rnn_1_1step_CC_maskV_-1.0=0.61876523, learning_rate=0.001\n", + "Epoch 43/131 - loss=rnn_1_1step_loss=0.42627135, rnn_1_1step_R2_maskV_-1.0=0.56542689, rnn_1_1step_CC_maskV_-1.0=0.75753725, rnn_1_1step_MSE_maskV_-1.0=0.42627132, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5271129, val_rnn_1_1step_R2_maskV_-1.0=0.38439912, val_rnn_1_1step_CC_maskV_-1.0=0.665209, learning_rate=0.001\n", + "Epoch 57/131 - loss=rnn_1_1step_loss=0.36727169, rnn_1_1step_R2_maskV_-1.0=0.62544525, rnn_1_1step_CC_maskV_-1.0=0.79551411, rnn_1_1step_MSE_maskV_-1.0=0.36727172, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50491011, val_rnn_1_1step_R2_maskV_-1.0=0.4096413, val_rnn_1_1step_CC_maskV_-1.0=0.68365043, learning_rate=0.001\n", + "Epoch 71/131 - loss=rnn_1_1step_loss=0.31886646, rnn_1_1step_R2_maskV_-1.0=0.67490149, rnn_1_1step_CC_maskV_-1.0=0.82509917, rnn_1_1step_MSE_maskV_-1.0=0.31886643, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49659863, val_rnn_1_1step_R2_maskV_-1.0=0.41928113, val_rnn_1_1step_CC_maskV_-1.0=0.6949569, learning_rate=0.001\n", + "Epoch 85/131 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.28832525, rnn_1_1step_R2_maskV_-1.0=0.70607436, rnn_1_1step_CC_maskV_-1.0=0.84323198, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48912728, val_rnn_1_1step_R2_maskV_-1.0=0.42741102, val_rnn_1_1step_CC_maskV_-1.0=0.70327431, learning_rate=0.001\n", + "Epoch 99/131 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.27199385, rnn_1_1step_R2_maskV_-1.0=0.72302306, rnn_1_1step_CC_maskV_-1.0=0.85286236, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48450884, val_rnn_1_1step_R2_maskV_-1.0=0.43271035, val_rnn_1_1step_CC_maskV_-1.0=0.70829833, learning_rate=0.001\n", + "Epoch 113/131 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.25397897, rnn_1_1step_R2_maskV_-1.0=0.74136567, rnn_1_1step_CC_maskV_-1.0=0.86324453, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49137256, val_rnn_1_1step_R2_maskV_-1.0=0.42349005, val_rnn_1_1step_CC_maskV_-1.0=0.70756161, learning_rate=0.001\n", + "Epoch 127/131 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.23221856, rnn_1_1step_R2_maskV_-1.0=0.76359361, rnn_1_1step_CC_maskV_-1.0=0.87587166, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48283565, val_rnn_1_1step_R2_maskV_-1.0=0.43389285, val_rnn_1_1step_CC_maskV_-1.0=0.71255565, learning_rate=0.001\n", + "Epoch 131/131 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.22980218, rnn_1_1step_R2_maskV_-1.0=0.76603031, rnn_1_1step_CC_maskV_-1.0=0.87712538, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49393597, val_rnn_1_1step_R2_maskV_-1.0=0.41983706, val_rnn_1_1step_CC_maskV_-1.0=0.70901954, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:42:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.94s\n", + "\u001b[32m2025-05-30 15:42:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.44388318)\n", + "\u001b[32m2025-05-30 15:42:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.167, R2_maskV_-1.0=0.833, CC_maskV_-1.0=0.913\n", + "\u001b[32m2025-05-30 15:42:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.384, R2_maskV_-1.0=0.559, CC_maskV_-1.0=0.783\n", + "\u001b[32m2025-05-30 15:42:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:42:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:43:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 160 (stopped at 175 epochs).\n", + "\u001b[32m2025-05-30 15:43:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/176 - loss=1.455452, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.093911879, MSE_maskV_-1.0=1.4543744, val_loss=1.0286697, val_CC_maskV_-1.0=0.17501362, val_MSE_maskV_-1.0=1.0249301, learning_rate=0.001\n", + "Epoch 19/176 - loss=0.8011108, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4468891, MSE_maskV_-1.0=0.80081213, val_loss=0.85647553, val_CC_maskV_-1.0=0.41745907, val_MSE_maskV_-1.0=0.8540647, learning_rate=0.001\n", + "Epoch 37/176 - loss=0.76033038, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49062276, MSE_maskV_-1.0=0.76064712, val_loss=0.81775242, val_CC_maskV_-1.0=0.46133012, val_MSE_maskV_-1.0=0.81543756, learning_rate=0.001\n", + "Epoch 55/176 - loss=0.73932242, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51138347, MSE_maskV_-1.0=0.73852116, val_loss=0.79686075, val_CC_maskV_-1.0=0.48023286, val_MSE_maskV_-1.0=0.7951988, learning_rate=0.001\n", + "Epoch 73/176 - loss=0.72764051, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52120018, MSE_maskV_-1.0=0.72781926, val_loss=0.78974444, val_CC_maskV_-1.0=0.48804852, val_MSE_maskV_-1.0=0.78820705, learning_rate=0.001\n", + "Epoch 91/176 - loss=0.71936595, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53023118, MSE_maskV_-1.0=0.72018629, val_loss=0.78124994, val_CC_maskV_-1.0=0.49451229, val_MSE_maskV_-1.0=0.78018403, learning_rate=0.001\n", + "Epoch 109/176 - loss=0.71283358, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5359093, MSE_maskV_-1.0=0.7124992, val_loss=0.77601826, val_CC_maskV_-1.0=0.50053781, val_MSE_maskV_-1.0=0.77492267, learning_rate=0.001\n", + "Epoch 127/176 - loss=0.70916229, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5384016, MSE_maskV_-1.0=0.71028709, val_loss=0.76896679, val_CC_maskV_-1.0=0.50730401, val_MSE_maskV_-1.0=0.76797593, learning_rate=0.001\n", + "Epoch 145/176 - loss=0.70377988, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5437907, MSE_maskV_-1.0=0.7042076, val_loss=0.76943231, val_CC_maskV_-1.0=0.50817895, val_MSE_maskV_-1.0=0.76855344, learning_rate=0.001\n", + "Epoch 163/176 - loss=0.69910854, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54849482, MSE_maskV_-1.0=0.69892108, val_loss=0.76524645, val_CC_maskV_-1.0=0.51228285, val_MSE_maskV_-1.0=0.76433671, learning_rate=0.001\n", + "Epoch 176/176 - loss=0.69760001, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54899186, MSE_maskV_-1.0=0.69710273, val_loss=0.75849777, val_CC_maskV_-1.0=0.51687324, val_MSE_maskV_-1.0=0.75761998, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:43:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 44.64s\n", + "\u001b[32m2025-05-30 15:43:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:44:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 172 (stopped at 187 epochs).\n", + "\u001b[32m2025-05-30 15:44:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/188 - loss=1.2463181, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.11104933, MSE_maskV_-1.0=1.2459135, val_loss=0.9978283, val_CC_maskV_-1.0=0.21401383, val_MSE_maskV_-1.0=0.99466348, learning_rate=0.001\n", + "Epoch 20/188 - loss=0.7922681, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45768005, MSE_maskV_-1.0=0.7919243, val_loss=0.84437096, val_CC_maskV_-1.0=0.43083027, val_MSE_maskV_-1.0=0.84201258, learning_rate=0.001\n", + "Epoch 39/188 - loss=0.75309336, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49750134, MSE_maskV_-1.0=0.75257295, val_loss=0.80628097, val_CC_maskV_-1.0=0.4714959, val_MSE_maskV_-1.0=0.80412, learning_rate=0.001\n", + "Epoch 58/188 - loss=0.73251778, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51757216, MSE_maskV_-1.0=0.73181796, val_loss=0.78849602, val_CC_maskV_-1.0=0.48869061, val_MSE_maskV_-1.0=0.78704131, learning_rate=0.001\n", + "Epoch 77/188 - loss=0.71948481, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52966321, MSE_maskV_-1.0=0.71897447, val_loss=0.77655268, val_CC_maskV_-1.0=0.50033826, val_MSE_maskV_-1.0=0.77514285, learning_rate=0.001\n", + "Epoch 96/188 - loss=0.71060276, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53674501, MSE_maskV_-1.0=0.70993072, val_loss=0.77630526, val_CC_maskV_-1.0=0.50102121, val_MSE_maskV_-1.0=0.77487642, learning_rate=0.001\n", + "Epoch 115/188 - loss=0.70529658, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5427295, MSE_maskV_-1.0=0.70589882, val_loss=0.76577365, val_CC_maskV_-1.0=0.50963384, val_MSE_maskV_-1.0=0.76468331, learning_rate=0.001\n", + "Epoch 134/188 - loss=0.70059782, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54744971, MSE_maskV_-1.0=0.70030636, val_loss=0.76696366, val_CC_maskV_-1.0=0.51050735, val_MSE_maskV_-1.0=0.76570517, learning_rate=0.001\n", + "Epoch 153/188 - loss=0.69636369, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55084789, MSE_maskV_-1.0=0.69587177, val_loss=0.75910556, val_CC_maskV_-1.0=0.51713991, val_MSE_maskV_-1.0=0.75777781, learning_rate=0.001\n", + "Epoch 172/188 - loss=0.6937964, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55311507, MSE_maskV_-1.0=0.6952008, val_loss=0.75488448, val_CC_maskV_-1.0=0.52083254, val_MSE_maskV_-1.0=0.75348496, learning_rate=0.001\n", + "Epoch 188/188 - loss=0.69146758, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55430138, MSE_maskV_-1.0=0.69089133, val_loss=0.75905263, val_CC_maskV_-1.0=0.51742166, val_MSE_maskV_-1.0=0.75809455, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:44:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 47.55s\n", + "\u001b[32m2025-05-30 15:44:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.75488448)\n", + "\u001b[32m2025-05-30 15:44:08\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 768us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:44:08\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.69, R2_maskV_-1.0=0.31, CC_maskV_-1.0=0.558\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 764us/step\n", + "51/51 [==============================] - 0s 793us/step\n", + "84/84 [==============================] - 0s 724us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:44:09\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_KCzCy1HL64U_ErSV16\" (15/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_KCzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:44:09\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 2/4 method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16\" (16/16)\n", + "\u001b[32m2025-05-30 15:44:09\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:44:09\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:44:09\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:44:09\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:44:09\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:44:09\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:44:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:44:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 106 (stopped at 121 epochs).\n", + "\u001b[32m2025-05-30 15:44:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/122 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0015192, rnn_1step_R2_maskV_-1.0=-0.014183525, rnn_1step_CC_maskV_-1.0=0.032040872, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92295218, val_rnn_1step_R2_maskV_-1.0=-0.064393669, val_rnn_1step_CC_maskV_-1.0=0.26276332, learning_rate=0.001\n", + "Epoch 14/122 - loss=rnn_1step_loss=0.83199018, rnn_1step_R2_maskV_-1.0=0.15762122, rnn_1step_CC_maskV_-1.0=0.41262877, rnn_1step_MSE_maskV_-1.0=0.83199012, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.77774477, val_rnn_1step_R2_maskV_-1.0=0.090393662, val_rnn_1step_CC_maskV_-1.0=0.39572144, learning_rate=0.001\n", + "Epoch 27/122 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.66206521, rnn_1step_R2_maskV_-1.0=0.32580459, rnn_1step_CC_maskV_-1.0=0.58164293, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.69014305, val_rnn_1step_R2_maskV_-1.0=0.19617392, val_rnn_1step_CC_maskV_-1.0=0.51187611, learning_rate=0.001\n", + "Epoch 40/122 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.56509846, rnn_1step_R2_maskV_-1.0=0.42305273, rnn_1step_CC_maskV_-1.0=0.66016251, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.66621733, val_rnn_1step_R2_maskV_-1.0=0.22637883, val_rnn_1step_CC_maskV_-1.0=0.5454458, learning_rate=0.001\n", + "Epoch 53/122 - loss=rnn_1step_loss=0.48358592, rnn_1step_R2_maskV_-1.0=0.50776964, rnn_1step_CC_maskV_-1.0=0.71861303, rnn_1step_MSE_maskV_-1.0=0.48358589, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58950996, val_rnn_1step_R2_maskV_-1.0=0.31025416, val_rnn_1step_CC_maskV_-1.0=0.61131889, learning_rate=0.001\n", + "Epoch 66/122 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4350909, rnn_1step_R2_maskV_-1.0=0.55770087, rnn_1step_CC_maskV_-1.0=0.75139761, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57245946, val_rnn_1step_R2_maskV_-1.0=0.32727143, val_rnn_1step_CC_maskV_-1.0=0.62422109, learning_rate=0.001\n", + "Epoch 79/122 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40107965, rnn_1step_R2_maskV_-1.0=0.59234923, rnn_1step_CC_maskV_-1.0=0.77323467, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55619377, val_rnn_1step_R2_maskV_-1.0=0.34703445, val_rnn_1step_CC_maskV_-1.0=0.63554102, learning_rate=0.001\n", + "Epoch 92/122 - loss=rnn_1step_loss=0.37568328, rnn_1step_R2_maskV_-1.0=0.61826813, rnn_1step_CC_maskV_-1.0=0.79038215, rnn_1step_MSE_maskV_-1.0=0.37568325, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53624141, val_rnn_1step_R2_maskV_-1.0=0.37028092, val_rnn_1step_CC_maskV_-1.0=0.64700615, learning_rate=0.001\n", + "Epoch 105/122 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34391955, rnn_1step_R2_maskV_-1.0=0.65093333, rnn_1step_CC_maskV_-1.0=0.81312686, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53524297, val_rnn_1step_R2_maskV_-1.0=0.37092429, val_rnn_1step_CC_maskV_-1.0=0.66041207, learning_rate=0.001\n", + "Epoch 118/122 - loss=rnn_1step_loss=0.30586788, rnn_1step_R2_maskV_-1.0=0.68959486, rnn_1step_CC_maskV_-1.0=0.83327055, rnn_1step_MSE_maskV_-1.0=0.30586785, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53411269, val_rnn_1step_R2_maskV_-1.0=0.3726449, val_rnn_1step_CC_maskV_-1.0=0.66254848, learning_rate=0.001\n", + "Epoch 122/122 - loss=rnn_1step_loss=0.29859948, rnn_1step_R2_maskV_-1.0=0.69695652, rnn_1step_CC_maskV_-1.0=0.83728278, rnn_1step_MSE_maskV_-1.0=0.29859945, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52696139, val_rnn_1step_R2_maskV_-1.0=0.38162765, val_rnn_1step_CC_maskV_-1.0=0.66497254, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:44:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.04s\n", + "\u001b[32m2025-05-30 15:44:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:44:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 78 (stopped at 93 epochs).\n", + "\u001b[32m2025-05-30 15:44:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/94 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0015235, rnn_1_1step_R2_maskV_-1.0=-0.014195368, rnn_1_1step_CC_maskV_-1.0=0.026953613, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.92309636, val_rnn_1_1step_R2_maskV_-1.0=-0.064563975, val_rnn_1_1step_CC_maskV_-1.0=0.27212858, learning_rate=0.001\n", + "Epoch 11/94 - loss=rnn_1_1step_loss=0.84208965, rnn_1_1step_R2_maskV_-1.0=0.14579608, rnn_1_1step_CC_maskV_-1.0=0.40441683, rnn_1_1step_MSE_maskV_-1.0=0.84208971, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.78884345, val_rnn_1_1step_R2_maskV_-1.0=0.07968381, val_rnn_1_1step_CC_maskV_-1.0=0.40076247, learning_rate=0.001\n", + "Epoch 21/94 - loss=rnn_1_1step_loss=0.6322763, rnn_1_1step_R2_maskV_-1.0=0.35300654, rnn_1_1step_CC_maskV_-1.0=0.60911757, rnn_1_1step_MSE_maskV_-1.0=0.63227624, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.68875784, val_rnn_1_1step_R2_maskV_-1.0=0.2009206, val_rnn_1_1step_CC_maskV_-1.0=0.51476347, learning_rate=0.001\n", + "Epoch 31/94 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.56787723, rnn_1_1step_R2_maskV_-1.0=0.41824874, rnn_1_1step_CC_maskV_-1.0=0.65854579, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65446097, val_rnn_1_1step_R2_maskV_-1.0=0.24051078, val_rnn_1_1step_CC_maskV_-1.0=0.54786032, learning_rate=0.001\n", + "Epoch 41/94 - loss=rnn_1_1step_loss=0.4999404, rnn_1_1step_R2_maskV_-1.0=0.48772821, rnn_1_1step_CC_maskV_-1.0=0.70855266, rnn_1_1step_MSE_maskV_-1.0=0.49994043, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61837858, val_rnn_1_1step_R2_maskV_-1.0=0.28485316, val_rnn_1_1step_CC_maskV_-1.0=0.58427978, learning_rate=0.001\n", + "Epoch 51/94 - loss=rnn_1_1step_loss=0.42206946, rnn_1_1step_R2_maskV_-1.0=0.56812125, rnn_1_1step_CC_maskV_-1.0=0.76143157, rnn_1_1step_MSE_maskV_-1.0=0.42206952, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5679161, val_rnn_1_1step_R2_maskV_-1.0=0.34364527, val_rnn_1_1step_CC_maskV_-1.0=0.62976962, learning_rate=0.001\n", + "Epoch 61/94 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36119357, rnn_1_1step_R2_maskV_-1.0=0.63124079, rnn_1_1step_CC_maskV_-1.0=0.79962754, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51156932, val_rnn_1_1step_R2_maskV_-1.0=0.40605867, val_rnn_1_1step_CC_maskV_-1.0=0.67623514, learning_rate=0.001\n", + "Epoch 71/94 - loss=rnn_1_1step_loss=0.32015124, rnn_1_1step_R2_maskV_-1.0=0.67373776, rnn_1_1step_CC_maskV_-1.0=0.82527196, rnn_1_1step_MSE_maskV_-1.0=0.32015127, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48280168, val_rnn_1_1step_R2_maskV_-1.0=0.4380554, val_rnn_1_1step_CC_maskV_-1.0=0.69789571, learning_rate=0.001\n", + "Epoch 81/94 - loss=rnn_1_1step_loss=0.28928146, rnn_1_1step_R2_maskV_-1.0=0.70549774, rnn_1_1step_CC_maskV_-1.0=0.84288168, rnn_1_1step_MSE_maskV_-1.0=0.28928143, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48597339, val_rnn_1_1step_R2_maskV_-1.0=0.43372911, val_rnn_1_1step_CC_maskV_-1.0=0.69949973, learning_rate=0.001\n", + "Epoch 91/94 - loss=rnn_1_1step_loss=0.26122424, rnn_1_1step_R2_maskV_-1.0=0.73425347, rnn_1_1step_CC_maskV_-1.0=0.85948634, rnn_1_1step_MSE_maskV_-1.0=0.26122421, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48505306, val_rnn_1_1step_R2_maskV_-1.0=0.43608955, val_rnn_1_1step_CC_maskV_-1.0=0.7017169, learning_rate=0.001\n", + "Epoch 94/94 - loss=rnn_1_1step_loss=0.25549069, rnn_1_1step_R2_maskV_-1.0=0.74016643, rnn_1_1step_CC_maskV_-1.0=0.86232936, rnn_1_1step_MSE_maskV_-1.0=0.25549072, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49421486, val_rnn_1_1step_R2_maskV_-1.0=0.42565835, val_rnn_1_1step_CC_maskV_-1.0=0.69762462, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:44:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.18s\n", + "\u001b[32m2025-05-30 15:44:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.47344175)\n", + "\u001b[32m2025-05-30 15:44:38\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.283, R2_maskV_-1.0=0.716, CC_maskV_-1.0=0.847\n", + "\u001b[32m2025-05-30 15:44:38\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.455, R2_maskV_-1.0=0.483, CC_maskV_-1.0=0.723\n", + "\u001b[32m2025-05-30 15:44:38\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:44:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:45:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 195 (stopped at 210 epochs).\n", + "\u001b[32m2025-05-30 15:45:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/211 - loss=1.0232362, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.1688921, MSE_maskV_-1.0=1.0232435, val_loss=0.96283609, val_CC_maskV_-1.0=0.26492718, val_MSE_maskV_-1.0=0.95957208, learning_rate=0.001\n", + "Epoch 23/211 - loss=0.78612107, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46340996, MSE_maskV_-1.0=0.78594774, val_loss=0.83725548, val_CC_maskV_-1.0=0.43380123, val_MSE_maskV_-1.0=0.83539224, learning_rate=0.001\n", + "Epoch 45/211 - loss=0.75734591, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49317625, MSE_maskV_-1.0=0.75701988, val_loss=0.81206661, val_CC_maskV_-1.0=0.45805725, val_MSE_maskV_-1.0=0.81050956, learning_rate=0.001\n", + "Epoch 67/211 - loss=0.74154484, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50829393, MSE_maskV_-1.0=0.74114347, val_loss=0.79819828, val_CC_maskV_-1.0=0.47320613, val_MSE_maskV_-1.0=0.79595339, learning_rate=0.001\n", + "Epoch 89/211 - loss=0.73054093, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51870829, MSE_maskV_-1.0=0.73076612, val_loss=0.78996593, val_CC_maskV_-1.0=0.48014304, val_MSE_maskV_-1.0=0.78771216, learning_rate=0.001\n", + "Epoch 111/211 - loss=0.7226395, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52620143, MSE_maskV_-1.0=0.72250652, val_loss=0.78043813, val_CC_maskV_-1.0=0.4893246, val_MSE_maskV_-1.0=0.77803212, learning_rate=0.001\n", + "Epoch 133/211 - loss=0.71464854, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53334188, MSE_maskV_-1.0=0.71390849, val_loss=0.78027314, val_CC_maskV_-1.0=0.48876518, val_MSE_maskV_-1.0=0.77733785, learning_rate=0.001\n", + "Epoch 155/211 - loss=0.70810235, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53869641, MSE_maskV_-1.0=0.70890939, val_loss=0.77151078, val_CC_maskV_-1.0=0.49785453, val_MSE_maskV_-1.0=0.76863164, learning_rate=0.001\n", + "Epoch 177/211 - loss=0.70360196, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54263037, MSE_maskV_-1.0=0.70315439, val_loss=0.76907295, val_CC_maskV_-1.0=0.50036526, val_MSE_maskV_-1.0=0.76667869, learning_rate=0.001\n", + "Epoch 199/211 - loss=0.69971937, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54607666, MSE_maskV_-1.0=0.6996268, val_loss=0.76564604, val_CC_maskV_-1.0=0.50484091, val_MSE_maskV_-1.0=0.76262802, learning_rate=0.001\n", + "Epoch 211/211 - loss=0.69733602, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54908502, MSE_maskV_-1.0=0.69682014, val_loss=0.76316786, val_CC_maskV_-1.0=0.50649589, val_MSE_maskV_-1.0=0.76071811, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:45:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 53.82s\n", + "\u001b[32m2025-05-30 15:45:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:46:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 90 (stopped at 105 epochs).\n", + "\u001b[32m2025-05-30 15:46:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/106 - loss=1.0327566, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.16941758, MSE_maskV_-1.0=1.0327958, val_loss=0.95929706, val_CC_maskV_-1.0=0.27281487, val_MSE_maskV_-1.0=0.95537305, learning_rate=0.001\n", + "Epoch 12/106 - loss=0.8180635, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42776987, MSE_maskV_-1.0=0.81856436, val_loss=0.86524624, val_CC_maskV_-1.0=0.406905, val_MSE_maskV_-1.0=0.8624773, learning_rate=0.001\n", + "Epoch 23/106 - loss=0.79062307, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45873785, MSE_maskV_-1.0=0.79039872, val_loss=0.84226352, val_CC_maskV_-1.0=0.42998567, val_MSE_maskV_-1.0=0.83997422, learning_rate=0.001\n", + "Epoch 34/106 - loss=0.77192557, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47837409, MSE_maskV_-1.0=0.77200121, val_loss=0.82206732, val_CC_maskV_-1.0=0.44906145, val_MSE_maskV_-1.0=0.82025933, learning_rate=0.001\n", + "Epoch 45/106 - loss=0.75923067, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49160305, MSE_maskV_-1.0=0.75881958, val_loss=0.8132295, val_CC_maskV_-1.0=0.45706218, val_MSE_maskV_-1.0=0.81171882, learning_rate=0.001\n", + "Epoch 56/106 - loss=0.75033689, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49935225, MSE_maskV_-1.0=0.75052267, val_loss=0.80491018, val_CC_maskV_-1.0=0.46537849, val_MSE_maskV_-1.0=0.80344415, learning_rate=0.001\n", + "Epoch 67/106 - loss=0.74365449, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50628614, MSE_maskV_-1.0=0.74328619, val_loss=0.79984748, val_CC_maskV_-1.0=0.47135723, val_MSE_maskV_-1.0=0.79816586, learning_rate=0.001\n", + "Epoch 78/106 - loss=0.73882264, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51035398, MSE_maskV_-1.0=0.7385177, val_loss=0.79986441, val_CC_maskV_-1.0=0.47240546, val_MSE_maskV_-1.0=0.79768139, learning_rate=0.001\n", + "Epoch 89/106 - loss=0.7340076, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51533103, MSE_maskV_-1.0=0.73419297, val_loss=0.79182261, val_CC_maskV_-1.0=0.47850585, val_MSE_maskV_-1.0=0.7903161, learning_rate=0.001\n", + "Epoch 100/106 - loss=0.73029852, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51790875, MSE_maskV_-1.0=0.73004031, val_loss=0.79443407, val_CC_maskV_-1.0=0.47660312, val_MSE_maskV_-1.0=0.7925154, learning_rate=0.001\n", + "Epoch 106/106 - loss=0.72814733, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52117598, MSE_maskV_-1.0=0.72792554, val_loss=0.78797668, val_CC_maskV_-1.0=0.4826692, val_MSE_maskV_-1.0=0.78605437, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:46:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 27.44s\n", + "\u001b[32m2025-05-30 15:46:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.76282972)\n", + "\u001b[32m2025-05-30 15:46:00\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 781us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:46:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.696, R2_maskV_-1.0=0.305, CC_maskV_-1.0=0.552\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 743us/step\n", + "51/51 [==============================] - 0s 822us/step\n", + "84/84 [==============================] - 0s 731us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:46:01\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 2/4 method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16\" (16/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4_DPAD_RTR2_uAKCzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:46:01\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1948] \u001b[1;30mINFO\u001b[0m Saving results for fold 2 as ..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f2_4.p\n", + "\u001b[32m2025-05-30 15:46:01\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1381] \u001b[1;30mINFO\u001b[0m Fold 3/4: training samples: 8014, test samples=2672\n", + "\u001b[32m2025-05-30 15:46:01\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1754] \u001b[1;30mINFO\u001b[0m Running fold 3 (NTrain=8014, NTest=2672)\n", + "\u001b[32m2025-05-30 15:46:01\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1849] \u001b[1;30mINFO\u001b[0m Signal dimensions: y => (10686, 46), z => (10686, 4), u => None\n", + "\u001b[32m2025-05-30 15:46:01\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1856] \u001b[1;30mINFO\u001b[0m Method codes to fit: ['DPAD_RTR2_ErSV16', 'DPAD_RTR2_A1HL64U_ErSV16', 'DPAD_RTR2_K1HL64U_ErSV16', 'DPAD_RTR2_Cz1HL64U_ErSV16', 'DPAD_RTR2_Cy1HL64U_ErSV16', 'DPAD_RTR2_uAK1HL64U_ErSV16', 'DPAD_RTR2_ACz1HL64U_ErSV16', 'DPAD_RTR2_ACy1HL64U_ErSV16', 'DPAD_RTR2_KCz1HL64U_ErSV16', 'DPAD_RTR2_KCy1HL64U_ErSV16', 'DPAD_RTR2_CzCy1HL64U_ErSV16', 'DPAD_RTR2_uAKCz1HL64U_ErSV16', 'DPAD_RTR2_uAKCy1HL64U_ErSV16', 'DPAD_RTR2_ACzCy1HL64U_ErSV16', 'DPAD_RTR2_KCzCy1HL64U_ErSV16', 'DPAD_RTR2_uAKCzCy1HL64U_ErSV16']\n", + "\u001b[32m2025-05-30 15:46:01\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1857] \u001b[1;30mINFO\u001b[0m Nx values to fit: [16]\n", + "\u001b[32m2025-05-30 15:46:01\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_ErSV16\" (1/16)\n", + "\u001b[32m2025-05-30 15:46:01\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:46:01\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:46:01\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:46:01\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:46:01\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:46:01\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:46:01\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:46:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 111 (stopped at 126 epochs).\n", + "\u001b[32m2025-05-30 15:46:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/127 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0010663, rnn_1step_R2_maskV_-1.0=-0.012324087, rnn_1step_CC_maskV_-1.0=0.039393369, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91051745, val_rnn_1step_R2_maskV_-1.0=-0.051741973, val_rnn_1step_CC_maskV_-1.0=0.18706469, learning_rate=0.001\n", + "Epoch 14/127 - loss=rnn_1step_loss=0.77259094, rnn_1step_R2_maskV_-1.0=0.21731207, rnn_1step_CC_maskV_-1.0=0.48777813, rnn_1step_MSE_maskV_-1.0=0.77259099, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.71093005, val_rnn_1step_R2_maskV_-1.0=0.17306739, val_rnn_1step_CC_maskV_-1.0=0.47890425, learning_rate=0.001\n", + "Epoch 27/127 - loss=rnn_1step_loss=0.5772211, rnn_1step_R2_maskV_-1.0=0.41019487, rnn_1step_CC_maskV_-1.0=0.64980179, rnn_1step_MSE_maskV_-1.0=0.57722116, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62429541, val_rnn_1step_R2_maskV_-1.0=0.27521527, val_rnn_1step_CC_maskV_-1.0=0.58589321, learning_rate=0.001\n", + "Epoch 40/127 - loss=rnn_1step_loss=0.52658266, rnn_1step_R2_maskV_-1.0=0.46169817, rnn_1step_CC_maskV_-1.0=0.68774253, rnn_1step_MSE_maskV_-1.0=0.5265826, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61131006, val_rnn_1step_R2_maskV_-1.0=0.29095697, val_rnn_1step_CC_maskV_-1.0=0.60683393, learning_rate=0.001\n", + "Epoch 53/127 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.50044638, rnn_1step_R2_maskV_-1.0=0.48828909, rnn_1step_CC_maskV_-1.0=0.70635116, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59893823, val_rnn_1step_R2_maskV_-1.0=0.30500039, val_rnn_1step_CC_maskV_-1.0=0.62118661, learning_rate=0.001\n", + "Epoch 66/127 - loss=rnn_1step_loss=0.48056826, rnn_1step_R2_maskV_-1.0=0.50896013, rnn_1step_CC_maskV_-1.0=0.72030967, rnn_1step_MSE_maskV_-1.0=0.48056823, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58318585, val_rnn_1step_R2_maskV_-1.0=0.32294822, val_rnn_1step_CC_maskV_-1.0=0.63412803, learning_rate=0.001\n", + "Epoch 79/127 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.44789514, rnn_1step_R2_maskV_-1.0=0.54285538, rnn_1step_CC_maskV_-1.0=0.74273062, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55880612, val_rnn_1step_R2_maskV_-1.0=0.35101187, val_rnn_1step_CC_maskV_-1.0=0.65404153, learning_rate=0.001\n", + "Epoch 92/127 - loss=rnn_1step_loss=0.43495488, rnn_1step_R2_maskV_-1.0=0.55598229, rnn_1step_CC_maskV_-1.0=0.75145435, rnn_1step_MSE_maskV_-1.0=0.43495491, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.549447, val_rnn_1step_R2_maskV_-1.0=0.36178643, val_rnn_1step_CC_maskV_-1.0=0.66267341, learning_rate=0.001\n", + "Epoch 105/127 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4286035, rnn_1step_R2_maskV_-1.0=0.56221044, rnn_1step_CC_maskV_-1.0=0.75569218, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54827911, val_rnn_1step_R2_maskV_-1.0=0.36299556, val_rnn_1step_CC_maskV_-1.0=0.66556013, learning_rate=0.001\n", + "Epoch 118/127 - loss=rnn_1step_loss=0.42428184, rnn_1step_R2_maskV_-1.0=0.56635952, rnn_1step_CC_maskV_-1.0=0.75854242, rnn_1step_MSE_maskV_-1.0=0.42428187, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54831856, val_rnn_1step_R2_maskV_-1.0=0.36287224, val_rnn_1step_CC_maskV_-1.0=0.66717005, learning_rate=0.001\n", + "Epoch 127/127 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42221084, rnn_1step_R2_maskV_-1.0=0.56831104, rnn_1step_CC_maskV_-1.0=0.75989735, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54892379, val_rnn_1step_R2_maskV_-1.0=0.36212814, val_rnn_1step_CC_maskV_-1.0=0.66769528, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:46:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.24s\n", + "\u001b[32m2025-05-30 15:46:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:46:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 28 (stopped at 43 epochs).\n", + "\u001b[32m2025-05-30 15:46:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/44 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.99838692, rnn_1_1step_R2_maskV_-1.0=-0.0097316094, rnn_1_1step_CC_maskV_-1.0=0.1032341, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91189033, val_rnn_1_1step_R2_maskV_-1.0=-0.053148702, val_rnn_1_1step_CC_maskV_-1.0=0.18702798, learning_rate=0.001\n", + "Epoch 6/44 - loss=rnn_1_1step_loss=0.95046592, rnn_1_1step_R2_maskV_-1.0=0.038804561, rnn_1_1step_CC_maskV_-1.0=0.40433586, rnn_1_1step_MSE_maskV_-1.0=0.95046598, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.8680954, val_rnn_1_1step_R2_maskV_-1.0=-0.0024575591, val_rnn_1_1step_CC_maskV_-1.0=0.37285239, learning_rate=0.001\n", + "Epoch 11/44 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.83636492, rnn_1_1step_R2_maskV_-1.0=0.15281478, rnn_1_1step_CC_maskV_-1.0=0.45103616, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.77218968, val_rnn_1_1step_R2_maskV_-1.0=0.10786945, val_rnn_1_1step_CC_maskV_-1.0=0.42053676, learning_rate=0.001\n", + "Epoch 16/44 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.71645671, rnn_1_1step_R2_maskV_-1.0=0.27085006, rnn_1_1step_CC_maskV_-1.0=0.53257519, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.69648057, val_rnn_1_1step_R2_maskV_-1.0=0.19387308, val_rnn_1_1step_CC_maskV_-1.0=0.49831471, learning_rate=0.001\n", + "Epoch 21/44 - loss=rnn_1_1step_loss=0.64441335, rnn_1_1step_R2_maskV_-1.0=0.34120774, rnn_1_1step_CC_maskV_-1.0=0.59631133, rnn_1_1step_MSE_maskV_-1.0=0.64441341, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65514952, val_rnn_1_1step_R2_maskV_-1.0=0.24085395, val_rnn_1_1step_CC_maskV_-1.0=0.54567266, learning_rate=0.001\n", + "Epoch 26/44 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.59982145, rnn_1_1step_R2_maskV_-1.0=0.38689005, rnn_1_1step_CC_maskV_-1.0=0.63219804, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63138288, val_rnn_1_1step_R2_maskV_-1.0=0.26850533, val_rnn_1_1step_CC_maskV_-1.0=0.56936568, learning_rate=0.001\n", + "Epoch 31/44 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.57348084, rnn_1_1step_R2_maskV_-1.0=0.41411471, rnn_1_1step_CC_maskV_-1.0=0.65267396, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62961864, val_rnn_1_1step_R2_maskV_-1.0=0.27065796, val_rnn_1_1step_CC_maskV_-1.0=0.57409, learning_rate=0.001\n", + "Epoch 36/44 - loss=rnn_1_1step_loss=0.55667567, rnn_1_1step_R2_maskV_-1.0=0.43137163, rnn_1_1step_CC_maskV_-1.0=0.66544878, rnn_1_1step_MSE_maskV_-1.0=0.55667561, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63082623, val_rnn_1_1step_R2_maskV_-1.0=0.26937297, val_rnn_1_1step_CC_maskV_-1.0=0.57695341, learning_rate=0.001\n", + "Epoch 41/44 - loss=rnn_1_1step_loss=0.54519492, rnn_1_1step_R2_maskV_-1.0=0.44311094, rnn_1_1step_CC_maskV_-1.0=0.67410785, rnn_1_1step_MSE_maskV_-1.0=0.54519486, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63153225, val_rnn_1_1step_R2_maskV_-1.0=0.26844388, val_rnn_1_1step_CC_maskV_-1.0=0.57997376, learning_rate=0.001\n", + "Epoch 44/44 - loss=rnn_1_1step_loss=0.53943437, rnn_1_1step_R2_maskV_-1.0=0.44902223, rnn_1_1step_CC_maskV_-1.0=0.67846036, rnn_1_1step_MSE_maskV_-1.0=0.53943431, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63093966, val_rnn_1_1step_R2_maskV_-1.0=0.26897436, val_rnn_1_1step_CC_maskV_-1.0=0.58210111, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:46:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 5.42s\n", + "\u001b[32m2025-05-30 15:46:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.54814929)\n", + "\u001b[32m2025-05-30 15:46:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.379, R2_maskV_-1.0=0.621, CC_maskV_-1.0=0.788\n", + "\u001b[32m2025-05-30 15:46:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.508, R2_maskV_-1.0=0.423, CC_maskV_-1.0=0.697\n", + "\u001b[32m2025-05-30 15:46:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:46:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:47:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 175 (stopped at 190 epochs).\n", + "\u001b[32m2025-05-30 15:47:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/191 - loss=3.6408072, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0011363868, MSE_maskV_-1.0=3.6333482, val_loss=1.3423171, val_CC_maskV_-1.0=0.023536621, val_MSE_maskV_-1.0=1.3365793, learning_rate=0.001\n", + "Epoch 21/191 - loss=0.85572404, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38238466, MSE_maskV_-1.0=0.85584915, val_loss=0.8839097, val_CC_maskV_-1.0=0.38042143, val_MSE_maskV_-1.0=0.88082141, learning_rate=0.001\n", + "Epoch 41/191 - loss=0.80701673, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44417951, MSE_maskV_-1.0=0.81071842, val_loss=0.8397513, val_CC_maskV_-1.0=0.43638727, val_MSE_maskV_-1.0=0.83703297, learning_rate=0.001\n", + "Epoch 61/191 - loss=0.78143317, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47279251, MSE_maskV_-1.0=0.78245068, val_loss=0.81728989, val_CC_maskV_-1.0=0.45977426, val_MSE_maskV_-1.0=0.81499588, learning_rate=0.001\n", + "Epoch 81/191 - loss=0.76603711, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48797187, MSE_maskV_-1.0=0.76617628, val_loss=0.80092919, val_CC_maskV_-1.0=0.47805583, val_MSE_maskV_-1.0=0.79826832, learning_rate=0.001\n", + "Epoch 101/191 - loss=0.75681216, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49651429, MSE_maskV_-1.0=0.75601143, val_loss=0.79199278, val_CC_maskV_-1.0=0.4856385, val_MSE_maskV_-1.0=0.78952712, learning_rate=0.001\n", + "Epoch 121/191 - loss=0.75016397, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50294268, MSE_maskV_-1.0=0.75009733, val_loss=0.78462481, val_CC_maskV_-1.0=0.49243698, val_MSE_maskV_-1.0=0.78198862, learning_rate=0.001\n", + "Epoch 141/191 - loss=0.74612552, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50648129, MSE_maskV_-1.0=0.74529344, val_loss=0.78282601, val_CC_maskV_-1.0=0.49406472, val_MSE_maskV_-1.0=0.780348, learning_rate=0.001\n", + "Epoch 161/191 - loss=0.74309498, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50823468, MSE_maskV_-1.0=0.74309963, val_loss=0.78070074, val_CC_maskV_-1.0=0.49486023, val_MSE_maskV_-1.0=0.7782445, learning_rate=0.001\n", + "Epoch 181/191 - loss=0.74105704, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51064962, MSE_maskV_-1.0=0.74163717, val_loss=0.77836668, val_CC_maskV_-1.0=0.49691987, val_MSE_maskV_-1.0=0.77597487, learning_rate=0.001\n", + "Epoch 191/191 - loss=0.74025881, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51044017, MSE_maskV_-1.0=0.7404061, val_loss=0.77496898, val_CC_maskV_-1.0=0.50030059, val_MSE_maskV_-1.0=0.77250594, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:47:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 45.66s\n", + "\u001b[32m2025-05-30 15:47:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:47:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 175 (stopped at 190 epochs).\n", + "\u001b[32m2025-05-30 15:47:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/191 - loss=2.8092749, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.045089867, MSE_maskV_-1.0=2.8042481, val_loss=1.2035704, val_CC_maskV_-1.0=0.090616673, val_MSE_maskV_-1.0=1.2017653, learning_rate=0.001\n", + "Epoch 21/191 - loss=0.85182369, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3874279, MSE_maskV_-1.0=0.85190088, val_loss=0.88399667, val_CC_maskV_-1.0=0.38071224, val_MSE_maskV_-1.0=0.88178492, learning_rate=0.001\n", + "Epoch 41/191 - loss=0.80578476, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44515577, MSE_maskV_-1.0=0.80985034, val_loss=0.840927, val_CC_maskV_-1.0=0.43488574, val_MSE_maskV_-1.0=0.83873093, learning_rate=0.001\n", + "Epoch 61/191 - loss=0.78124952, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47274056, MSE_maskV_-1.0=0.78228539, val_loss=0.81863314, val_CC_maskV_-1.0=0.45804641, val_MSE_maskV_-1.0=0.81671357, learning_rate=0.001\n", + "Epoch 81/191 - loss=0.76616639, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48776686, MSE_maskV_-1.0=0.76627898, val_loss=0.80186898, val_CC_maskV_-1.0=0.47676554, val_MSE_maskV_-1.0=0.79948574, learning_rate=0.001\n", + "Epoch 101/191 - loss=0.75702268, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49621788, MSE_maskV_-1.0=0.75622666, val_loss=0.79303354, val_CC_maskV_-1.0=0.48435196, val_MSE_maskV_-1.0=0.79077101, learning_rate=0.001\n", + "Epoch 121/191 - loss=0.75037158, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50267577, MSE_maskV_-1.0=0.75031912, val_loss=0.78532004, val_CC_maskV_-1.0=0.49152732, val_MSE_maskV_-1.0=0.78285342, learning_rate=0.001\n", + "Epoch 141/191 - loss=0.74631536, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50623697, MSE_maskV_-1.0=0.74548948, val_loss=0.78335983, val_CC_maskV_-1.0=0.49330539, val_MSE_maskV_-1.0=0.78103924, learning_rate=0.001\n", + "Epoch 161/191 - loss=0.74325323, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50801849, MSE_maskV_-1.0=0.74325669, val_loss=0.78111118, val_CC_maskV_-1.0=0.49421909, val_MSE_maskV_-1.0=0.77878022, learning_rate=0.001\n", + "Epoch 181/191 - loss=0.74118841, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51051044, MSE_maskV_-1.0=0.74175769, val_loss=0.77875078, val_CC_maskV_-1.0=0.49631849, val_MSE_maskV_-1.0=0.7764616, learning_rate=0.001\n", + "Epoch 191/191 - loss=0.74037498, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51030314, MSE_maskV_-1.0=0.74051118, val_loss=0.77528673, val_CC_maskV_-1.0=0.49977082, val_MSE_maskV_-1.0=0.77293164, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:47:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 44.52s\n", + "\u001b[32m2025-05-30 15:47:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.77380091)\n", + "\u001b[32m2025-05-30 15:47:50\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 743us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:47:50\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.74, R2_maskV_-1.0=0.26, CC_maskV_-1.0=0.512\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 673us/step\n", + "51/51 [==============================] - 0s 770us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:47:51\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_ErSV16\" (1/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:47:51\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_A1HL64U_ErSV16\" (2/16)\n", + "\u001b[32m2025-05-30 15:47:51\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_A1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:47:51\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:47:51\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:47:51\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:47:51\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:47:51\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:47:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:48:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 51 (stopped at 66 epochs).\n", + "\u001b[32m2025-05-30 15:48:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/67 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.99944359, rnn_1step_R2_maskV_-1.0=-0.01062914, rnn_1step_CC_maskV_-1.0=0.074012019, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91239756, val_rnn_1step_R2_maskV_-1.0=-0.05411613, val_rnn_1step_CC_maskV_-1.0=0.14684896, learning_rate=0.001\n", + "Epoch 8/67 - loss=rnn_1step_loss=0.91510361, rnn_1step_R2_maskV_-1.0=0.074386045, rnn_1step_CC_maskV_-1.0=0.41355592, rnn_1step_MSE_maskV_-1.0=0.91510367, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.83720905, val_rnn_1step_R2_maskV_-1.0=0.031062245, val_rnn_1step_CC_maskV_-1.0=0.35442543, learning_rate=0.001\n", + "Epoch 15/67 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.75299531, rnn_1step_R2_maskV_-1.0=0.2356199, rnn_1step_CC_maskV_-1.0=0.50439334, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.72170287, val_rnn_1step_R2_maskV_-1.0=0.16118254, val_rnn_1step_CC_maskV_-1.0=0.45758951, learning_rate=0.001\n", + "Epoch 22/67 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.64006251, rnn_1step_R2_maskV_-1.0=0.34834427, rnn_1step_CC_maskV_-1.0=0.59971362, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.68544292, val_rnn_1step_R2_maskV_-1.0=0.20375174, val_rnn_1step_CC_maskV_-1.0=0.51499599, learning_rate=0.001\n", + "Epoch 29/67 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.57119364, rnn_1step_R2_maskV_-1.0=0.41629481, rnn_1step_CC_maskV_-1.0=0.65417004, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.66081792, val_rnn_1step_R2_maskV_-1.0=0.23368306, val_rnn_1step_CC_maskV_-1.0=0.55305457, learning_rate=0.001\n", + "Epoch 36/67 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.53152627, rnn_1step_R2_maskV_-1.0=0.45501155, rnn_1step_CC_maskV_-1.0=0.68380469, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63629436, val_rnn_1step_R2_maskV_-1.0=0.26291567, val_rnn_1step_CC_maskV_-1.0=0.58603871, learning_rate=0.001\n", + "Epoch 43/67 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.49594998, rnn_1step_R2_maskV_-1.0=0.48984745, rnn_1step_CC_maskV_-1.0=0.70949244, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62524492, val_rnn_1step_R2_maskV_-1.0=0.27584121, val_rnn_1step_CC_maskV_-1.0=0.6045292, learning_rate=0.001\n", + "Epoch 50/67 - loss=rnn_1step_loss=0.46087983, rnn_1step_R2_maskV_-1.0=0.52467775, rnn_1step_CC_maskV_-1.0=0.73364282, rnn_1step_MSE_maskV_-1.0=0.46087986, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6142652, val_rnn_1step_R2_maskV_-1.0=0.28759009, val_rnn_1step_CC_maskV_-1.0=0.61845315, learning_rate=0.001\n", + "Epoch 57/67 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.43095958, rnn_1step_R2_maskV_-1.0=0.55535012, rnn_1step_CC_maskV_-1.0=0.75392431, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62681943, val_rnn_1step_R2_maskV_-1.0=0.27215582, val_rnn_1step_CC_maskV_-1.0=0.61735386, learning_rate=0.001\n", + "Epoch 64/67 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41230896, rnn_1step_R2_maskV_-1.0=0.57469714, rnn_1step_CC_maskV_-1.0=0.76631385, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63098669, val_rnn_1step_R2_maskV_-1.0=0.26718992, val_rnn_1step_CC_maskV_-1.0=0.61642683, learning_rate=0.001\n", + "Epoch 67/67 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40791509, rnn_1step_R2_maskV_-1.0=0.57949972, rnn_1step_CC_maskV_-1.0=0.76922047, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61709923, val_rnn_1step_R2_maskV_-1.0=0.28354883, val_rnn_1step_CC_maskV_-1.0=0.62171876, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:48:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 9.24s\n", + "\u001b[32m2025-05-30 15:48:01\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:48:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 56 (stopped at 71 epochs).\n", + "\u001b[32m2025-05-30 15:48:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/72 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.99810314, rnn_1_1step_R2_maskV_-1.0=-0.009378206, rnn_1_1step_CC_maskV_-1.0=0.097263813, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91157484, val_rnn_1_1step_R2_maskV_-1.0=-0.052859977, val_rnn_1_1step_CC_maskV_-1.0=0.16326553, learning_rate=0.001\n", + "Epoch 9/72 - loss=rnn_1_1step_loss=0.88596553, rnn_1_1step_R2_maskV_-1.0=0.1043672, rnn_1_1step_CC_maskV_-1.0=0.4257797, rnn_1_1step_MSE_maskV_-1.0=0.88596547, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.81180638, val_rnn_1_1step_R2_maskV_-1.0=0.059039786, val_rnn_1_1step_CC_maskV_-1.0=0.38604274, learning_rate=0.001\n", + "Epoch 17/72 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.71346951, rnn_1_1step_R2_maskV_-1.0=0.27535826, rnn_1_1step_CC_maskV_-1.0=0.53720623, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.69654959, val_rnn_1_1step_R2_maskV_-1.0=0.19131686, val_rnn_1_1step_CC_maskV_-1.0=0.49562371, learning_rate=0.001\n", + "Epoch 25/72 - loss=rnn_1_1step_loss=0.6133706, rnn_1_1step_R2_maskV_-1.0=0.37457216, rnn_1_1step_CC_maskV_-1.0=0.62165165, rnn_1_1step_MSE_maskV_-1.0=0.61337054, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.657682, val_rnn_1_1step_R2_maskV_-1.0=0.23712388, val_rnn_1_1step_CC_maskV_-1.0=0.54404563, learning_rate=0.001\n", + "Epoch 33/72 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.55387807, rnn_1_1step_R2_maskV_-1.0=0.43347883, rnn_1_1step_CC_maskV_-1.0=0.66734469, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63739967, val_rnn_1_1step_R2_maskV_-1.0=0.26130968, val_rnn_1_1step_CC_maskV_-1.0=0.57405561, learning_rate=0.001\n", + "Epoch 41/72 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.52027541, rnn_1_1step_R2_maskV_-1.0=0.46647456, rnn_1_1step_CC_maskV_-1.0=0.69210237, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63613111, val_rnn_1_1step_R2_maskV_-1.0=0.26297832, val_rnn_1_1step_CC_maskV_-1.0=0.58530414, learning_rate=0.001\n", + "Epoch 49/72 - loss=rnn_1_1step_loss=0.49027717, rnn_1_1step_R2_maskV_-1.0=0.49617857, rnn_1_1step_CC_maskV_-1.0=0.71335298, rnn_1_1step_MSE_maskV_-1.0=0.4902772, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63378662, val_rnn_1_1step_R2_maskV_-1.0=0.26530123, val_rnn_1_1step_CC_maskV_-1.0=0.59510183, learning_rate=0.001\n", + "Epoch 57/72 - loss=rnn_1_1step_loss=0.46320453, rnn_1_1step_R2_maskV_-1.0=0.52304041, rnn_1_1step_CC_maskV_-1.0=0.73223162, rnn_1_1step_MSE_maskV_-1.0=0.46320459, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63145202, val_rnn_1_1step_R2_maskV_-1.0=0.26693138, val_rnn_1_1step_CC_maskV_-1.0=0.60890532, learning_rate=0.001\n", + "Epoch 65/72 - loss=rnn_1_1step_loss=0.43179831, rnn_1_1step_R2_maskV_-1.0=0.55470622, rnn_1_1step_CC_maskV_-1.0=0.75332224, rnn_1_1step_MSE_maskV_-1.0=0.43179834, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61677921, val_rnn_1_1step_R2_maskV_-1.0=0.28401268, val_rnn_1_1step_CC_maskV_-1.0=0.61586314, learning_rate=0.001\n", + "Epoch 72/72 - loss=rnn_1_1step_loss=0.41290393, rnn_1_1step_R2_maskV_-1.0=0.57396472, rnn_1_1step_CC_maskV_-1.0=0.76592976, rnn_1_1step_MSE_maskV_-1.0=0.41290396, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6242795, val_rnn_1_1step_R2_maskV_-1.0=0.27454633, val_rnn_1_1step_CC_maskV_-1.0=0.61828548, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:48:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 9.50s\n", + "\u001b[32m2025-05-30 15:48:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.59433341)\n", + "\u001b[32m2025-05-30 15:48:11\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.446, R2_maskV_-1.0=0.554, CC_maskV_-1.0=0.745\n", + "\u001b[32m2025-05-30 15:48:12\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.58, R2_maskV_-1.0=0.343, CC_maskV_-1.0=0.637\n", + "\u001b[32m2025-05-30 15:48:12\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:48:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:48:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 121 (stopped at 136 epochs).\n", + "\u001b[32m2025-05-30 15:48:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/137 - loss=1.4450614, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.051508598, MSE_maskV_-1.0=1.4444301, val_loss=1.062629, val_CC_maskV_-1.0=0.14149249, val_MSE_maskV_-1.0=1.0606151, learning_rate=0.001\n", + "Epoch 15/137 - loss=0.82015103, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43202752, MSE_maskV_-1.0=0.81930202, val_loss=0.84202594, val_CC_maskV_-1.0=0.4337194, val_MSE_maskV_-1.0=0.84035367, learning_rate=0.001\n", + "Epoch 29/137 - loss=0.77839899, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47790933, MSE_maskV_-1.0=0.77770442, val_loss=0.79741311, val_CC_maskV_-1.0=0.4786191, val_MSE_maskV_-1.0=0.79608321, learning_rate=0.001\n", + "Epoch 43/137 - loss=0.76188177, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49171528, MSE_maskV_-1.0=0.76151741, val_loss=0.78121597, val_CC_maskV_-1.0=0.49133202, val_MSE_maskV_-1.0=0.78006971, learning_rate=0.001\n", + "Epoch 57/137 - loss=0.75434929, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49844843, MSE_maskV_-1.0=0.75488806, val_loss=0.77457625, val_CC_maskV_-1.0=0.49610758, val_MSE_maskV_-1.0=0.7733832, learning_rate=0.001\n", + "Epoch 71/137 - loss=0.75046986, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50092214, MSE_maskV_-1.0=0.75145984, val_loss=0.76838356, val_CC_maskV_-1.0=0.50132102, val_MSE_maskV_-1.0=0.76727855, learning_rate=0.001\n", + "Epoch 85/137 - loss=0.74822944, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50277078, MSE_maskV_-1.0=0.74837333, val_loss=0.76758397, val_CC_maskV_-1.0=0.50162715, val_MSE_maskV_-1.0=0.7666772, learning_rate=0.001\n", + "Epoch 99/137 - loss=0.74698776, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5033198, MSE_maskV_-1.0=0.74640262, val_loss=0.76528138, val_CC_maskV_-1.0=0.50439781, val_MSE_maskV_-1.0=0.76397181, learning_rate=0.001\n", + "Epoch 113/137 - loss=0.7462371, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50422931, MSE_maskV_-1.0=0.7496888, val_loss=0.76357168, val_CC_maskV_-1.0=0.50595415, val_MSE_maskV_-1.0=0.76224697, learning_rate=0.001\n", + "Epoch 127/137 - loss=0.74592388, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50477576, MSE_maskV_-1.0=0.74610281, val_loss=0.76380253, val_CC_maskV_-1.0=0.50548786, val_MSE_maskV_-1.0=0.76275462, learning_rate=0.001\n", + "Epoch 137/137 - loss=0.74552494, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50529683, MSE_maskV_-1.0=0.74583405, val_loss=0.76532376, val_CC_maskV_-1.0=0.50320041, val_MSE_maskV_-1.0=0.7645759, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:48:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 33.09s\n", + "\u001b[32m2025-05-30 15:48:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:49:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 121 (stopped at 136 epochs).\n", + "\u001b[32m2025-05-30 15:49:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/137 - loss=1.3775711, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.057403233, MSE_maskV_-1.0=1.3767904, val_loss=1.0499475, val_CC_maskV_-1.0=0.13868257, val_MSE_maskV_-1.0=1.0474225, learning_rate=0.001\n", + "Epoch 15/137 - loss=0.81687105, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43584263, MSE_maskV_-1.0=0.81601608, val_loss=0.83843231, val_CC_maskV_-1.0=0.4362627, val_MSE_maskV_-1.0=0.83672386, learning_rate=0.001\n", + "Epoch 29/137 - loss=0.77614093, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48015481, MSE_maskV_-1.0=0.77545547, val_loss=0.79488474, val_CC_maskV_-1.0=0.48069179, val_MSE_maskV_-1.0=0.79351783, learning_rate=0.001\n", + "Epoch 43/137 - loss=0.76038349, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49311081, MSE_maskV_-1.0=0.76002747, val_loss=0.77947354, val_CC_maskV_-1.0=0.49296769, val_MSE_maskV_-1.0=0.77826768, learning_rate=0.001\n", + "Epoch 57/137 - loss=0.75336665, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49935514, MSE_maskV_-1.0=0.7539115, val_loss=0.7734406, val_CC_maskV_-1.0=0.4972226, val_MSE_maskV_-1.0=0.77221245, learning_rate=0.001\n", + "Epoch 71/137 - loss=0.74983615, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50147861, MSE_maskV_-1.0=0.75081658, val_loss=0.7676158, val_CC_maskV_-1.0=0.50216001, val_MSE_maskV_-1.0=0.76645905, learning_rate=0.001\n", + "Epoch 85/137 - loss=0.74781746, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5031504, MSE_maskV_-1.0=0.74794781, val_loss=0.76708043, val_CC_maskV_-1.0=0.50219756, val_MSE_maskV_-1.0=0.76613665, learning_rate=0.001\n", + "Epoch 99/137 - loss=0.7467255, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50354272, MSE_maskV_-1.0=0.74614143, val_loss=0.76496136, val_CC_maskV_-1.0=0.50479251, val_MSE_maskV_-1.0=0.76362139, learning_rate=0.001\n", + "Epoch 113/137 - loss=0.74606526, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50437611, MSE_maskV_-1.0=0.74951953, val_loss=0.76335883, val_CC_maskV_-1.0=0.50621539, val_MSE_maskV_-1.0=0.76201773, learning_rate=0.001\n", + "Epoch 127/137 - loss=0.74581325, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50486052, MSE_maskV_-1.0=0.74599493, val_loss=0.76364946, val_CC_maskV_-1.0=0.50567925, val_MSE_maskV_-1.0=0.76258832, learning_rate=0.001\n", + "Epoch 137/137 - loss=0.74544388, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50535917, MSE_maskV_-1.0=0.74575418, val_loss=0.76520264, val_CC_maskV_-1.0=0.50336862, val_MSE_maskV_-1.0=0.76443976, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:49:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 32.57s\n", + "\u001b[32m2025-05-30 15:49:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.76234061)\n", + "\u001b[32m2025-05-30 15:49:17\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 720us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:49:18\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.745, R2_maskV_-1.0=0.255, CC_maskV_-1.0=0.506\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 695us/step\n", + "51/51 [==============================] - 0s 792us/step\n", + "84/84 [==============================] - 0s 679us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:49:18\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_A1HL64U_ErSV16\" (2/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_A1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:49:18\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_K1HL64U_ErSV16\" (3/16)\n", + "\u001b[32m2025-05-30 15:49:18\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_K1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:49:18\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:49:18\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:49:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:49:19\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:49:19\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:49:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:49:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 77 (stopped at 92 epochs).\n", + "\u001b[32m2025-05-30 15:49:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/93 - loss=rnn_1step_loss=1.0014771, rnn_1step_R2_maskV_-1.0=-0.012764003, rnn_1step_CC_maskV_-1.0=0.1228371, rnn_1step_MSE_maskV_-1.0=1.0014772, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91779566, val_rnn_1step_R2_maskV_-1.0=-0.060081825, val_rnn_1step_CC_maskV_-1.0=0.21278301, learning_rate=0.001\n", + "Epoch 11/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.82689166, rnn_1step_R2_maskV_-1.0=0.16056336, rnn_1step_CC_maskV_-1.0=0.4227308, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.76008034, val_rnn_1step_R2_maskV_-1.0=0.11540562, val_rnn_1step_CC_maskV_-1.0=0.42325169, learning_rate=0.001\n", + "Epoch 21/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.61719012, rnn_1step_R2_maskV_-1.0=0.36955738, rnn_1step_CC_maskV_-1.0=0.61907589, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64759797, val_rnn_1step_R2_maskV_-1.0=0.24677217, val_rnn_1step_CC_maskV_-1.0=0.55439866, learning_rate=0.001\n", + "Epoch 31/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.51974732, rnn_1step_R2_maskV_-1.0=0.46693245, rnn_1step_CC_maskV_-1.0=0.69259828, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61424369, val_rnn_1step_R2_maskV_-1.0=0.285981, val_rnn_1step_CC_maskV_-1.0=0.59369475, learning_rate=0.001\n", + "Epoch 41/93 - loss=rnn_1step_loss=0.4445301, rnn_1step_R2_maskV_-1.0=0.54365438, rnn_1step_CC_maskV_-1.0=0.74508184, rnn_1step_MSE_maskV_-1.0=0.44453007, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57917303, val_rnn_1step_R2_maskV_-1.0=0.32700956, val_rnn_1step_CC_maskV_-1.0=0.63053584, learning_rate=0.001\n", + "Epoch 51/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3794215, rnn_1step_R2_maskV_-1.0=0.61041176, rnn_1step_CC_maskV_-1.0=0.78769898, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54776233, val_rnn_1step_R2_maskV_-1.0=0.36291939, val_rnn_1step_CC_maskV_-1.0=0.65862966, learning_rate=0.001\n", + "Epoch 61/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3360889, rnn_1step_R2_maskV_-1.0=0.6553843, rnn_1step_CC_maskV_-1.0=0.8147077, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5266645, val_rnn_1step_R2_maskV_-1.0=0.3876375, val_rnn_1step_CC_maskV_-1.0=0.67748308, learning_rate=0.001\n", + "Epoch 71/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.28251186, rnn_1step_R2_maskV_-1.0=0.71074444, rnn_1step_CC_maskV_-1.0=0.84704894, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49903071, val_rnn_1step_R2_maskV_-1.0=0.4206737, val_rnn_1step_CC_maskV_-1.0=0.7017051, learning_rate=0.001\n", + "Epoch 81/93 - loss=rnn_1step_loss=0.24431737, rnn_1step_R2_maskV_-1.0=0.74967319, rnn_1step_CC_maskV_-1.0=0.86942631, rnn_1step_MSE_maskV_-1.0=0.24431738, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49188018, val_rnn_1step_R2_maskV_-1.0=0.42947367, val_rnn_1step_CC_maskV_-1.0=0.71338111, learning_rate=0.001\n", + "Epoch 91/93 - loss=rnn_1step_loss=0.22480105, rnn_1step_R2_maskV_-1.0=0.76954699, rnn_1step_CC_maskV_-1.0=0.88061893, rnn_1step_MSE_maskV_-1.0=0.22480106, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49958089, val_rnn_1step_R2_maskV_-1.0=0.42062384, val_rnn_1step_CC_maskV_-1.0=0.71414876, learning_rate=0.001\n", + "Epoch 93/93 - loss=rnn_1step_loss=0.22164385, rnn_1step_R2_maskV_-1.0=0.77274179, rnn_1step_CC_maskV_-1.0=0.88241053, rnn_1step_MSE_maskV_-1.0=0.22164384, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50114703, val_rnn_1step_R2_maskV_-1.0=0.41880068, val_rnn_1step_CC_maskV_-1.0=0.71420336, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:49:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.32s\n", + "\u001b[32m2025-05-30 15:49:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:49:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 77 (stopped at 92 epochs).\n", + "\u001b[32m2025-05-30 15:49:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/93 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0017641, rnn_1_1step_R2_maskV_-1.0=-0.013040114, rnn_1_1step_CC_maskV_-1.0=0.074930899, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91574496, val_rnn_1_1step_R2_maskV_-1.0=-0.05762215, val_rnn_1_1step_CC_maskV_-1.0=0.3277145, learning_rate=0.001\n", + "Epoch 11/93 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.84245014, rnn_1_1step_R2_maskV_-1.0=0.14793026, rnn_1_1step_CC_maskV_-1.0=0.40222543, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.76461935, val_rnn_1_1step_R2_maskV_-1.0=0.11408371, val_rnn_1_1step_CC_maskV_-1.0=0.41263539, learning_rate=0.001\n", + "Epoch 21/93 - loss=rnn_1_1step_loss=0.62883925, rnn_1_1step_R2_maskV_-1.0=0.35852641, rnn_1_1step_CC_maskV_-1.0=0.61001307, rnn_1_1step_MSE_maskV_-1.0=0.62883919, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65117723, val_rnn_1_1step_R2_maskV_-1.0=0.24339367, val_rnn_1_1step_CC_maskV_-1.0=0.54454839, learning_rate=0.001\n", + "Epoch 31/93 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.52054822, rnn_1_1step_R2_maskV_-1.0=0.46840903, rnn_1_1step_CC_maskV_-1.0=0.69256699, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61080998, val_rnn_1_1step_R2_maskV_-1.0=0.29029286, val_rnn_1_1step_CC_maskV_-1.0=0.59156615, learning_rate=0.001\n", + "Epoch 41/93 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.43830916, rnn_1_1step_R2_maskV_-1.0=0.5516637, rnn_1_1step_CC_maskV_-1.0=0.74930704, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57868022, val_rnn_1_1step_R2_maskV_-1.0=0.32798606, val_rnn_1_1step_CC_maskV_-1.0=0.63086396, learning_rate=0.001\n", + "Epoch 51/93 - loss=rnn_1_1step_loss=0.3862896, rnn_1_1step_R2_maskV_-1.0=0.60437918, rnn_1_1step_CC_maskV_-1.0=0.78333414, rnn_1_1step_MSE_maskV_-1.0=0.38628963, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55180526, val_rnn_1_1step_R2_maskV_-1.0=0.35830897, val_rnn_1_1step_CC_maskV_-1.0=0.65540481, learning_rate=0.001\n", + "Epoch 61/93 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.34223166, rnn_1_1step_R2_maskV_-1.0=0.64975506, rnn_1_1step_CC_maskV_-1.0=0.81097823, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52935487, val_rnn_1_1step_R2_maskV_-1.0=0.38418972, val_rnn_1_1step_CC_maskV_-1.0=0.67425072, learning_rate=0.001\n", + "Epoch 71/93 - loss=rnn_1_1step_loss=0.28859603, rnn_1_1step_R2_maskV_-1.0=0.70559657, rnn_1_1step_CC_maskV_-1.0=0.84349215, rnn_1_1step_MSE_maskV_-1.0=0.28859606, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50756854, val_rnn_1_1step_R2_maskV_-1.0=0.41005516, val_rnn_1_1step_CC_maskV_-1.0=0.69433832, learning_rate=0.001\n", + "Epoch 81/93 - loss=rnn_1_1step_loss=0.24747036, rnn_1_1step_R2_maskV_-1.0=0.74740458, rnn_1_1step_CC_maskV_-1.0=0.86752641, rnn_1_1step_MSE_maskV_-1.0=0.24747035, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50534064, val_rnn_1_1step_R2_maskV_-1.0=0.41313604, val_rnn_1_1step_CC_maskV_-1.0=0.70270205, learning_rate=0.001\n", + "Epoch 91/93 - loss=rnn_1_1step_loss=0.22892718, rnn_1_1step_R2_maskV_-1.0=0.76613808, rnn_1_1step_CC_maskV_-1.0=0.87814921, rnn_1_1step_MSE_maskV_-1.0=0.22892717, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51305056, val_rnn_1_1step_R2_maskV_-1.0=0.40449232, val_rnn_1_1step_CC_maskV_-1.0=0.70175713, learning_rate=0.001\n", + "Epoch 93/93 - loss=rnn_1_1step_loss=0.22624063, rnn_1_1step_R2_maskV_-1.0=0.76883489, rnn_1_1step_CC_maskV_-1.0=0.87967843, rnn_1_1step_MSE_maskV_-1.0=0.22624065, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51461941, val_rnn_1_1step_R2_maskV_-1.0=0.40267587, val_rnn_1_1step_CC_maskV_-1.0=0.70146543, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:49:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.34s\n", + "\u001b[32m2025-05-30 15:49:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.48886225)\n", + "\u001b[32m2025-05-30 15:49:41\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.23, R2_maskV_-1.0=0.771, CC_maskV_-1.0=0.878\n", + "\u001b[32m2025-05-30 15:49:41\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.451, R2_maskV_-1.0=0.49, CC_maskV_-1.0=0.738\n", + "\u001b[32m2025-05-30 15:49:41\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:49:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:51:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 429 (stopped at 444 epochs).\n", + "\u001b[32m2025-05-30 15:51:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/445 - loss=1.4458808, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.054806564, MSE_maskV_-1.0=1.4448534, val_loss=1.0363075, val_CC_maskV_-1.0=0.12608446, val_MSE_maskV_-1.0=1.033815, learning_rate=0.001\n", + "Epoch 46/445 - loss=0.88104767, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35262635, MSE_maskV_-1.0=0.88233203, val_loss=0.90505016, val_CC_maskV_-1.0=0.35843179, val_MSE_maskV_-1.0=0.90260607, learning_rate=0.001\n", + "Epoch 91/445 - loss=0.8541593, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38953772, MSE_maskV_-1.0=0.8546204, val_loss=0.87578481, val_CC_maskV_-1.0=0.39721814, val_MSE_maskV_-1.0=0.87314522, learning_rate=0.001\n", + "Epoch 136/445 - loss=0.8392812, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40744814, MSE_maskV_-1.0=0.84022295, val_loss=0.86004889, val_CC_maskV_-1.0=0.41575462, val_MSE_maskV_-1.0=0.85709828, learning_rate=0.001\n", + "Epoch 181/445 - loss=0.82973057, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41808099, MSE_maskV_-1.0=0.83042657, val_loss=0.85036653, val_CC_maskV_-1.0=0.42506236, val_MSE_maskV_-1.0=0.84771472, learning_rate=0.001\n", + "Epoch 226/445 - loss=0.8231529, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42413339, MSE_maskV_-1.0=0.82282299, val_loss=0.84416002, val_CC_maskV_-1.0=0.43153909, val_MSE_maskV_-1.0=0.84119302, learning_rate=0.001\n", + "Epoch 271/445 - loss=0.81787795, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43068683, MSE_maskV_-1.0=0.81769413, val_loss=0.83847034, val_CC_maskV_-1.0=0.43712091, val_MSE_maskV_-1.0=0.83556682, learning_rate=0.001\n", + "Epoch 316/445 - loss=0.81392628, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43468347, MSE_maskV_-1.0=0.81385666, val_loss=0.83357537, val_CC_maskV_-1.0=0.44213334, val_MSE_maskV_-1.0=0.83115977, learning_rate=0.001\n", + "Epoch 361/445 - loss=0.81077725, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4379501, MSE_maskV_-1.0=0.81128895, val_loss=0.82865578, val_CC_maskV_-1.0=0.44598418, val_MSE_maskV_-1.0=0.82621717, learning_rate=0.001\n", + "Epoch 406/445 - loss=0.80827361, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44029808, MSE_maskV_-1.0=0.80880678, val_loss=0.82650703, val_CC_maskV_-1.0=0.4483116, val_MSE_maskV_-1.0=0.82391202, learning_rate=0.001\n", + "Epoch 445/445 - loss=0.80663216, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44234568, MSE_maskV_-1.0=0.80672598, val_loss=0.82474619, val_CC_maskV_-1.0=0.44905511, val_MSE_maskV_-1.0=0.82260096, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:51:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 104.95s\n", + "\u001b[32m2025-05-30 15:51:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:53:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 429 (stopped at 444 epochs).\n", + "\u001b[32m2025-05-30 15:53:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/445 - loss=1.3422083, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.069552712, MSE_maskV_-1.0=1.3415372, val_loss=1.0171794, val_CC_maskV_-1.0=0.15091546, val_MSE_maskV_-1.0=1.0154848, learning_rate=0.001\n", + "Epoch 46/445 - loss=0.8807376, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35297918, MSE_maskV_-1.0=0.88201535, val_loss=0.90446264, val_CC_maskV_-1.0=0.36006317, val_MSE_maskV_-1.0=0.90188426, learning_rate=0.001\n", + "Epoch 91/445 - loss=0.85421503, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38931581, MSE_maskV_-1.0=0.85469109, val_loss=0.87575346, val_CC_maskV_-1.0=0.39785051, val_MSE_maskV_-1.0=0.87298858, learning_rate=0.001\n", + "Epoch 136/445 - loss=0.83939224, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40724084, MSE_maskV_-1.0=0.84031743, val_loss=0.8603434, val_CC_maskV_-1.0=0.41584167, val_MSE_maskV_-1.0=0.85729045, learning_rate=0.001\n", + "Epoch 181/445 - loss=0.82981253, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41797459, MSE_maskV_-1.0=0.83051878, val_loss=0.85075372, val_CC_maskV_-1.0=0.42500073, val_MSE_maskV_-1.0=0.8479957, learning_rate=0.001\n", + "Epoch 226/445 - loss=0.82319909, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42410269, MSE_maskV_-1.0=0.82287508, val_loss=0.8445214, val_CC_maskV_-1.0=0.43144661, val_MSE_maskV_-1.0=0.8414765, learning_rate=0.001\n", + "Epoch 271/445 - loss=0.81788564, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43069702, MSE_maskV_-1.0=0.81770939, val_loss=0.83885735, val_CC_maskV_-1.0=0.43695465, val_MSE_maskV_-1.0=0.83588809, learning_rate=0.001\n", + "Epoch 316/445 - loss=0.81390059, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43472123, MSE_maskV_-1.0=0.81382382, val_loss=0.83393532, val_CC_maskV_-1.0=0.44200879, val_MSE_maskV_-1.0=0.83144403, learning_rate=0.001\n", + "Epoch 361/445 - loss=0.81072778, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43803841, MSE_maskV_-1.0=0.81123596, val_loss=0.82899201, val_CC_maskV_-1.0=0.44587058, val_MSE_maskV_-1.0=0.8264882, learning_rate=0.001\n", + "Epoch 406/445 - loss=0.80821323, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44039139, MSE_maskV_-1.0=0.80875194, val_loss=0.82686526, val_CC_maskV_-1.0=0.44815612, val_MSE_maskV_-1.0=0.82420176, learning_rate=0.001\n", + "Epoch 445/445 - loss=0.80656695, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44243273, MSE_maskV_-1.0=0.80666369, val_loss=0.82505083, val_CC_maskV_-1.0=0.44893798, val_MSE_maskV_-1.0=0.82284021, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:53:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 103.97s\n", + "\u001b[32m2025-05-30 15:53:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.8239128)\n", + "\u001b[32m2025-05-30 15:53:10\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 738us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:53:10\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.806, R2_maskV_-1.0=0.194, CC_maskV_-1.0=0.442\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 703us/step\n", + "51/51 [==============================] - 0s 655us/step\n", + "84/84 [==============================] - 0s 719us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:53:11\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_K1HL64U_ErSV16\" (3/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_K1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:53:11\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_Cz1HL64U_ErSV16\" (4/16)\n", + "\u001b[32m2025-05-30 15:53:11\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_Cz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:53:11\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:53:11\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:53:11\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:53:11\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:53:11\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:53:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:53:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 151 (stopped at 166 epochs).\n", + "\u001b[32m2025-05-30 15:53:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0016203, rnn_1step_R2_maskV_-1.0=-0.012931157, rnn_1step_CC_maskV_-1.0=0.10425955, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91636753, val_rnn_1step_R2_maskV_-1.0=-0.058289409, val_rnn_1step_CC_maskV_-1.0=0.25780898, learning_rate=0.001\n", + "Epoch 18/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.6622147, rnn_1step_R2_maskV_-1.0=0.32468855, rnn_1step_CC_maskV_-1.0=0.58423084, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.66748601, val_rnn_1step_R2_maskV_-1.0=0.22778705, val_rnn_1step_CC_maskV_-1.0=0.52444148, learning_rate=0.001\n", + "Epoch 35/167 - loss=rnn_1step_loss=0.48840031, rnn_1step_R2_maskV_-1.0=0.49987531, rnn_1step_CC_maskV_-1.0=0.71482772, rnn_1step_MSE_maskV_-1.0=0.48840028, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59414631, val_rnn_1step_R2_maskV_-1.0=0.31005764, val_rnn_1step_CC_maskV_-1.0=0.61971951, learning_rate=0.001\n", + "Epoch 52/167 - loss=rnn_1step_loss=0.43340221, rnn_1step_R2_maskV_-1.0=0.55480438, rnn_1step_CC_maskV_-1.0=0.75246191, rnn_1step_MSE_maskV_-1.0=0.43340224, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57429767, val_rnn_1step_R2_maskV_-1.0=0.33171737, val_rnn_1step_CC_maskV_-1.0=0.64206678, learning_rate=0.001\n", + "Epoch 69/167 - loss=rnn_1step_loss=0.41508138, rnn_1step_R2_maskV_-1.0=0.57288349, rnn_1step_CC_maskV_-1.0=0.76465768, rnn_1step_MSE_maskV_-1.0=0.41508135, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56303817, val_rnn_1step_R2_maskV_-1.0=0.34511438, val_rnn_1step_CC_maskV_-1.0=0.65066129, learning_rate=0.001\n", + "Epoch 86/167 - loss=rnn_1step_loss=0.4011766, rnn_1step_R2_maskV_-1.0=0.58684546, rnn_1step_CC_maskV_-1.0=0.77379215, rnn_1step_MSE_maskV_-1.0=0.40117663, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55357176, val_rnn_1step_R2_maskV_-1.0=0.35661936, val_rnn_1step_CC_maskV_-1.0=0.65752894, learning_rate=0.001\n", + "Epoch 103/167 - loss=rnn_1step_loss=0.3871713, rnn_1step_R2_maskV_-1.0=0.60111374, rnn_1step_CC_maskV_-1.0=0.78280872, rnn_1step_MSE_maskV_-1.0=0.38717133, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5458231, val_rnn_1step_R2_maskV_-1.0=0.3662833, val_rnn_1step_CC_maskV_-1.0=0.66320896, learning_rate=0.001\n", + "Epoch 120/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37092009, rnn_1step_R2_maskV_-1.0=0.61772728, rnn_1step_CC_maskV_-1.0=0.79307711, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53540832, val_rnn_1step_R2_maskV_-1.0=0.37909433, val_rnn_1step_CC_maskV_-1.0=0.67162853, learning_rate=0.001\n", + "Epoch 137/167 - loss=rnn_1step_loss=0.35239685, rnn_1step_R2_maskV_-1.0=0.6367718, rnn_1step_CC_maskV_-1.0=0.80457336, rnn_1step_MSE_maskV_-1.0=0.35239688, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52148008, val_rnn_1step_R2_maskV_-1.0=0.39571667, val_rnn_1step_CC_maskV_-1.0=0.68435174, learning_rate=0.001\n", + "Epoch 154/167 - loss=rnn_1step_loss=0.3396658, rnn_1step_R2_maskV_-1.0=0.64971828, rnn_1step_CC_maskV_-1.0=0.8125056, rnn_1step_MSE_maskV_-1.0=0.33966577, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51639611, val_rnn_1step_R2_maskV_-1.0=0.40143487, val_rnn_1step_CC_maskV_-1.0=0.69267738, learning_rate=0.001\n", + "Epoch 167/167 - loss=rnn_1step_loss=0.33384189, rnn_1step_R2_maskV_-1.0=0.65559232, rnn_1step_CC_maskV_-1.0=0.81613135, rnn_1step_MSE_maskV_-1.0=0.33384186, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51812625, val_rnn_1step_R2_maskV_-1.0=0.39927426, val_rnn_1step_CC_maskV_-1.0=0.69408864, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:53:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 17.21s\n", + "\u001b[32m2025-05-30 15:53:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:53:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 185 (stopped at 200 epochs).\n", + "\u001b[32m2025-05-30 15:53:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/201 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0013524, rnn_1_1step_R2_maskV_-1.0=-0.012654144, rnn_1_1step_CC_maskV_-1.0=0.11663375, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.9162218, val_rnn_1_1step_R2_maskV_-1.0=-0.058156684, val_rnn_1_1step_CC_maskV_-1.0=0.24654578, learning_rate=0.001\n", + "Epoch 22/201 - loss=rnn_1_1step_loss=0.68557692, rnn_1_1step_R2_maskV_-1.0=0.29995328, rnn_1_1step_CC_maskV_-1.0=0.56251848, rnn_1_1step_MSE_maskV_-1.0=0.68557698, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.66578925, val_rnn_1_1step_R2_maskV_-1.0=0.22643857, val_rnn_1_1step_CC_maskV_-1.0=0.52874243, learning_rate=0.001\n", + "Epoch 43/201 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.53238469, rnn_1_1step_R2_maskV_-1.0=0.45437324, rnn_1_1step_CC_maskV_-1.0=0.68380761, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60621548, val_rnn_1_1step_R2_maskV_-1.0=0.29561508, val_rnn_1_1step_CC_maskV_-1.0=0.600012, learning_rate=0.001\n", + "Epoch 64/201 - loss=rnn_1_1step_loss=0.45708799, rnn_1_1step_R2_maskV_-1.0=0.53044468, rnn_1_1step_CC_maskV_-1.0=0.73652714, rnn_1_1step_MSE_maskV_-1.0=0.45708796, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58913863, val_rnn_1_1step_R2_maskV_-1.0=0.31542489, val_rnn_1_1step_CC_maskV_-1.0=0.63282162, learning_rate=0.001\n", + "Epoch 85/201 - loss=rnn_1_1step_loss=0.41591683, rnn_1_1step_R2_maskV_-1.0=0.57193714, rnn_1_1step_CC_maskV_-1.0=0.76400191, rnn_1_1step_MSE_maskV_-1.0=0.41591686, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57810903, val_rnn_1_1step_R2_maskV_-1.0=0.32709128, val_rnn_1_1step_CC_maskV_-1.0=0.64689082, learning_rate=0.001\n", + "Epoch 106/201 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39622757, rnn_1_1step_R2_maskV_-1.0=0.5918771, rnn_1_1step_CC_maskV_-1.0=0.77674043, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56593084, val_rnn_1_1step_R2_maskV_-1.0=0.34122729, val_rnn_1_1step_CC_maskV_-1.0=0.6557135, learning_rate=0.001\n", + "Epoch 127/201 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.37645793, rnn_1_1step_R2_maskV_-1.0=0.61233187, rnn_1_1step_CC_maskV_-1.0=0.78930449, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55052948, val_rnn_1_1step_R2_maskV_-1.0=0.35980707, val_rnn_1_1step_CC_maskV_-1.0=0.66650593, learning_rate=0.001\n", + "Epoch 148/201 - loss=rnn_1_1step_loss=0.34886864, rnn_1_1step_R2_maskV_-1.0=0.64076763, rnn_1_1step_CC_maskV_-1.0=0.8066417, rnn_1_1step_MSE_maskV_-1.0=0.34886867, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52659035, val_rnn_1_1step_R2_maskV_-1.0=0.38903722, val_rnn_1_1step_CC_maskV_-1.0=0.68689853, learning_rate=0.001\n", + "Epoch 169/201 - loss=rnn_1_1step_loss=0.33674422, rnn_1_1step_R2_maskV_-1.0=0.65279824, rnn_1_1step_CC_maskV_-1.0=0.81411165, rnn_1_1step_MSE_maskV_-1.0=0.33674425, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51618451, val_rnn_1_1step_R2_maskV_-1.0=0.4014259, val_rnn_1_1step_CC_maskV_-1.0=0.6971181, learning_rate=0.001\n", + "Epoch 190/201 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33077279, rnn_1_1step_R2_maskV_-1.0=0.65874749, rnn_1_1step_CC_maskV_-1.0=0.81778604, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51583618, val_rnn_1_1step_R2_maskV_-1.0=0.40180153, val_rnn_1_1step_CC_maskV_-1.0=0.69909537, learning_rate=0.001\n", + "Epoch 201/201 - loss=rnn_1_1step_loss=0.32809404, rnn_1_1step_R2_maskV_-1.0=0.66143608, rnn_1_1step_CC_maskV_-1.0=0.81943917, rnn_1_1step_MSE_maskV_-1.0=0.32809407, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51678216, val_rnn_1_1step_R2_maskV_-1.0=0.40068626, val_rnn_1_1step_CC_maskV_-1.0=0.69929832, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:53:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 20.14s\n", + "\u001b[32m2025-05-30 15:53:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.51552862)\n", + "\u001b[32m2025-05-30 15:53:50\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.297, R2_maskV_-1.0=0.702, CC_maskV_-1.0=0.838\n", + "\u001b[32m2025-05-30 15:53:50\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.476, R2_maskV_-1.0=0.461, CC_maskV_-1.0=0.728\n", + "\u001b[32m2025-05-30 15:53:50\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:53:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:54:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 175 (stopped at 190 epochs).\n", + "\u001b[32m2025-05-30 15:54:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/191 - loss=5.3568501, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.043617938, MSE_maskV_-1.0=5.3448601, val_loss=1.7488079, val_CC_maskV_-1.0=0.082046069, val_MSE_maskV_-1.0=1.7389379, learning_rate=0.001\n", + "Epoch 21/191 - loss=0.80519462, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44195861, MSE_maskV_-1.0=0.80526328, val_loss=0.82815105, val_CC_maskV_-1.0=0.44224602, val_MSE_maskV_-1.0=0.82605398, learning_rate=0.001\n", + "Epoch 41/191 - loss=0.75498396, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4958466, MSE_maskV_-1.0=0.75938141, val_loss=0.78458863, val_CC_maskV_-1.0=0.48647526, val_MSE_maskV_-1.0=0.78243351, learning_rate=0.001\n", + "Epoch 61/191 - loss=0.7372961, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51414621, MSE_maskV_-1.0=0.73815817, val_loss=0.766581, val_CC_maskV_-1.0=0.50330305, val_MSE_maskV_-1.0=0.76456976, learning_rate=0.001\n", + "Epoch 81/191 - loss=0.72762895, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52307749, MSE_maskV_-1.0=0.7278406, val_loss=0.75179064, val_CC_maskV_-1.0=0.51763296, val_MSE_maskV_-1.0=0.74954194, learning_rate=0.001\n", + "Epoch 101/191 - loss=0.72242588, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52761281, MSE_maskV_-1.0=0.72169405, val_loss=0.75132114, val_CC_maskV_-1.0=0.51688749, val_MSE_maskV_-1.0=0.74922734, learning_rate=0.001\n", + "Epoch 121/191 - loss=0.71904701, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53088927, MSE_maskV_-1.0=0.71902931, val_loss=0.74334943, val_CC_maskV_-1.0=0.52457088, val_MSE_maskV_-1.0=0.74112749, learning_rate=0.001\n", + "Epoch 141/191 - loss=0.7168715, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53265667, MSE_maskV_-1.0=0.7160514, val_loss=0.74046594, val_CC_maskV_-1.0=0.52718234, val_MSE_maskV_-1.0=0.73834872, learning_rate=0.001\n", + "Epoch 161/191 - loss=0.71559185, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5337289, MSE_maskV_-1.0=0.71564686, val_loss=0.73992032, val_CC_maskV_-1.0=0.5277853, val_MSE_maskV_-1.0=0.73774701, learning_rate=0.001\n", + "Epoch 181/191 - loss=0.71400237, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53548694, MSE_maskV_-1.0=0.71461874, val_loss=0.74468571, val_CC_maskV_-1.0=0.52345222, val_MSE_maskV_-1.0=0.74247807, learning_rate=0.001\n", + "Epoch 191/191 - loss=0.71364594, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53518701, MSE_maskV_-1.0=0.71367168, val_loss=0.74057776, val_CC_maskV_-1.0=0.52719212, val_MSE_maskV_-1.0=0.73824376, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:54:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 48.83s\n", + "\u001b[32m2025-05-30 15:54:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:55:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 117 (stopped at 132 epochs).\n", + "\u001b[32m2025-05-30 15:55:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/133 - loss=4.1550794, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.049920272, MSE_maskV_-1.0=4.1462436, val_loss=1.4674404, val_CC_maskV_-1.0=0.096821241, val_MSE_maskV_-1.0=1.4660963, learning_rate=0.001\n", + "Epoch 15/133 - loss=0.8311851, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41095525, MSE_maskV_-1.0=0.83034635, val_loss=0.85723287, val_CC_maskV_-1.0=0.40731066, val_MSE_maskV_-1.0=0.85605305, learning_rate=0.001\n", + "Epoch 29/133 - loss=0.77774096, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47272116, MSE_maskV_-1.0=0.77702379, val_loss=0.8009972, val_CC_maskV_-1.0=0.46878126, val_MSE_maskV_-1.0=0.79969668, learning_rate=0.001\n", + "Epoch 43/133 - loss=0.75377548, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49718419, MSE_maskV_-1.0=0.75346982, val_loss=0.77568108, val_CC_maskV_-1.0=0.49461246, val_MSE_maskV_-1.0=0.77399701, learning_rate=0.001\n", + "Epoch 57/133 - loss=0.74100649, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51004565, MSE_maskV_-1.0=0.74153203, val_loss=0.7665711, val_CC_maskV_-1.0=0.50252771, val_MSE_maskV_-1.0=0.764696, learning_rate=0.001\n", + "Epoch 71/133 - loss=0.73362619, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51652199, MSE_maskV_-1.0=0.73511046, val_loss=0.75831914, val_CC_maskV_-1.0=0.50969762, val_MSE_maskV_-1.0=0.75647557, learning_rate=0.001\n", + "Epoch 85/133 - loss=0.72790706, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52262968, MSE_maskV_-1.0=0.72778767, val_loss=0.75509715, val_CC_maskV_-1.0=0.51322889, val_MSE_maskV_-1.0=0.75320631, learning_rate=0.001\n", + "Epoch 99/133 - loss=0.72455478, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52480149, MSE_maskV_-1.0=0.7241134, val_loss=0.74888265, val_CC_maskV_-1.0=0.51928103, val_MSE_maskV_-1.0=0.74670619, learning_rate=0.001\n", + "Epoch 113/133 - loss=0.72169584, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52741367, MSE_maskV_-1.0=0.725205, val_loss=0.75183487, val_CC_maskV_-1.0=0.51692849, val_MSE_maskV_-1.0=0.74979693, learning_rate=0.001\n", + "Epoch 127/133 - loss=0.71958709, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52967453, MSE_maskV_-1.0=0.71987647, val_loss=0.74491531, val_CC_maskV_-1.0=0.52294302, val_MSE_maskV_-1.0=0.74290532, learning_rate=0.001\n", + "Epoch 133/133 - loss=0.71947515, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53017789, MSE_maskV_-1.0=0.71923125, val_loss=0.74237823, val_CC_maskV_-1.0=0.52558744, val_MSE_maskV_-1.0=0.74058807, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:55:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 32.21s\n", + "\u001b[32m2025-05-30 15:55:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.73661423)\n", + "\u001b[32m2025-05-30 15:55:11\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 734us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:55:11\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.711, R2_maskV_-1.0=0.288, CC_maskV_-1.0=0.538\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 763us/step\n", + "51/51 [==============================] - 0s 758us/step\n", + "84/84 [==============================] - 0s 672us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:55:12\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_Cz1HL64U_ErSV16\" (4/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_Cz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:55:12\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_Cy1HL64U_ErSV16\" (5/16)\n", + "\u001b[32m2025-05-30 15:55:12\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_Cy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:55:12\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:55:12\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:55:12\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:55:12\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:55:12\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:55:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:55:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 47 (stopped at 62 epochs).\n", + "\u001b[32m2025-05-30 15:55:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/63 - loss=rnn_1step_loss=0.99739486, rnn_1step_R2_maskV_-1.0=-0.0084911026, rnn_1step_CC_maskV_-1.0=0.12802924, rnn_1step_MSE_maskV_-1.0=0.99739492, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91113299, val_rnn_1step_R2_maskV_-1.0=-0.052156374, val_rnn_1step_CC_maskV_-1.0=0.19729303, learning_rate=0.001\n", + "Epoch 8/63 - loss=rnn_1step_loss=0.90293735, rnn_1step_R2_maskV_-1.0=0.087320417, rnn_1step_CC_maskV_-1.0=0.4589994, rnn_1step_MSE_maskV_-1.0=0.90293729, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.82786673, val_rnn_1step_R2_maskV_-1.0=0.043423831, val_rnn_1step_CC_maskV_-1.0=0.4014937, learning_rate=0.001\n", + "Epoch 15/63 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.70934421, rnn_1step_R2_maskV_-1.0=0.27673346, rnn_1step_CC_maskV_-1.0=0.53938735, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.69602633, val_rnn_1step_R2_maskV_-1.0=0.19296171, val_rnn_1step_CC_maskV_-1.0=0.50171161, learning_rate=0.001\n", + "Epoch 22/63 - loss=rnn_1step_loss=0.60951263, rnn_1step_R2_maskV_-1.0=0.37702036, rnn_1step_CC_maskV_-1.0=0.62479693, rnn_1step_MSE_maskV_-1.0=0.60951257, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63418096, val_rnn_1step_R2_maskV_-1.0=0.26450861, val_rnn_1step_CC_maskV_-1.0=0.56781888, learning_rate=0.001\n", + "Epoch 29/63 - loss=rnn_1step_loss=0.56665206, rnn_1step_R2_maskV_-1.0=0.42009407, rnn_1step_CC_maskV_-1.0=0.65773368, rnn_1step_MSE_maskV_-1.0=0.56665212, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62623692, val_rnn_1step_R2_maskV_-1.0=0.27375156, val_rnn_1step_CC_maskV_-1.0=0.58209163, learning_rate=0.001\n", + "Epoch 36/63 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.54226953, rnn_1step_R2_maskV_-1.0=0.44490793, rnn_1step_CC_maskV_-1.0=0.67615336, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61989588, val_rnn_1step_R2_maskV_-1.0=0.28081155, val_rnn_1step_CC_maskV_-1.0=0.59242159, learning_rate=0.001\n", + "Epoch 43/63 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.52130991, rnn_1step_R2_maskV_-1.0=0.46650034, rnn_1step_CC_maskV_-1.0=0.69167531, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61444908, val_rnn_1step_R2_maskV_-1.0=0.28644055, val_rnn_1step_CC_maskV_-1.0=0.60086042, learning_rate=0.001\n", + "Epoch 50/63 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.50664717, rnn_1step_R2_maskV_-1.0=0.48194039, rnn_1step_CC_maskV_-1.0=0.70212424, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61414254, val_rnn_1step_R2_maskV_-1.0=0.28600913, val_rnn_1step_CC_maskV_-1.0=0.60375631, learning_rate=0.001\n", + "Epoch 57/63 - loss=rnn_1step_loss=0.50090623, rnn_1step_R2_maskV_-1.0=0.4879961, rnn_1step_CC_maskV_-1.0=0.7062667, rnn_1step_MSE_maskV_-1.0=0.50090629, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61505324, val_rnn_1step_R2_maskV_-1.0=0.28475165, val_rnn_1step_CC_maskV_-1.0=0.603544, learning_rate=0.001\n", + "Epoch 63/63 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.49800694, rnn_1step_R2_maskV_-1.0=0.49098116, rnn_1step_CC_maskV_-1.0=0.70837498, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61425906, val_rnn_1step_R2_maskV_-1.0=0.28567815, val_rnn_1step_CC_maskV_-1.0=0.60413563, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:55:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 7.11s\n", + "\u001b[32m2025-05-30 15:55:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:55:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 161 (stopped at 176 epochs).\n", + "\u001b[32m2025-05-30 15:55:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/177 - loss=rnn_1_1step_loss=1.0024747, rnn_1_1step_R2_maskV_-1.0=-0.013822127, rnn_1_1step_CC_maskV_-1.0=0.0081219617, rnn_1_1step_MSE_maskV_-1.0=1.0024745, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91540509, val_rnn_1_1step_R2_maskV_-1.0=-0.057565004, val_rnn_1_1step_CC_maskV_-1.0=0.095643364, learning_rate=0.001\n", + "Epoch 19/177 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.71425152, rnn_1_1step_R2_maskV_-1.0=0.27432477, rnn_1_1step_CC_maskV_-1.0=0.53662467, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.69136304, val_rnn_1_1step_R2_maskV_-1.0=0.19627883, val_rnn_1_1step_CC_maskV_-1.0=0.49833474, learning_rate=0.001\n", + "Epoch 37/177 - loss=rnn_1_1step_loss=0.55344421, rnn_1_1step_R2_maskV_-1.0=0.43483201, rnn_1_1step_CC_maskV_-1.0=0.66791707, rnn_1_1step_MSE_maskV_-1.0=0.55344415, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.634444, val_rnn_1_1step_R2_maskV_-1.0=0.26459199, val_rnn_1_1step_CC_maskV_-1.0=0.57702017, learning_rate=0.001\n", + "Epoch 55/177 - loss=rnn_1_1step_loss=0.50491399, rnn_1_1step_R2_maskV_-1.0=0.48447853, rnn_1_1step_CC_maskV_-1.0=0.70380926, rnn_1_1step_MSE_maskV_-1.0=0.50491393, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61363298, val_rnn_1_1step_R2_maskV_-1.0=0.28608063, val_rnn_1_1step_CC_maskV_-1.0=0.60302263, learning_rate=0.001\n", + "Epoch 73/177 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.48801196, rnn_1_1step_R2_maskV_-1.0=0.50158417, rnn_1_1step_CC_maskV_-1.0=0.71559179, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60392702, val_rnn_1_1step_R2_maskV_-1.0=0.29718915, val_rnn_1_1step_CC_maskV_-1.0=0.61156923, learning_rate=0.001\n", + "Epoch 91/177 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.47663197, rnn_1_1step_R2_maskV_-1.0=0.51314253, rnn_1_1step_CC_maskV_-1.0=0.7234903, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5937956, val_rnn_1_1step_R2_maskV_-1.0=0.30912805, val_rnn_1_1step_CC_maskV_-1.0=0.61991954, learning_rate=0.001\n", + "Epoch 109/177 - loss=rnn_1_1step_loss=0.46183944, rnn_1_1step_R2_maskV_-1.0=0.52811372, rnn_1_1step_CC_maskV_-1.0=0.7335875, rnn_1_1step_MSE_maskV_-1.0=0.46183941, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57965297, val_rnn_1_1step_R2_maskV_-1.0=0.3257432, val_rnn_1_1step_CC_maskV_-1.0=0.63204163, learning_rate=0.001\n", + "Epoch 127/177 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44339991, rnn_1_1step_R2_maskV_-1.0=0.54666656, rnn_1_1step_CC_maskV_-1.0=0.74588954, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56104976, val_rnn_1_1step_R2_maskV_-1.0=0.34764415, val_rnn_1_1step_CC_maskV_-1.0=0.64865559, learning_rate=0.001\n", + "Epoch 145/177 - loss=rnn_1_1step_loss=0.42728508, rnn_1_1step_R2_maskV_-1.0=0.56270301, rnn_1_1step_CC_maskV_-1.0=0.75643098, rnn_1_1step_MSE_maskV_-1.0=0.4272851, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54670382, val_rnn_1_1step_R2_maskV_-1.0=0.36459464, val_rnn_1_1step_CC_maskV_-1.0=0.66295809, learning_rate=0.001\n", + "Epoch 163/177 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.4194622, rnn_1_1step_R2_maskV_-1.0=0.57036126, rnn_1_1step_CC_maskV_-1.0=0.76154739, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54413676, val_rnn_1_1step_R2_maskV_-1.0=0.36763436, val_rnn_1_1step_CC_maskV_-1.0=0.66802436, learning_rate=0.001\n", + "Epoch 177/177 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41648254, rnn_1_1step_R2_maskV_-1.0=0.57325387, rnn_1_1step_CC_maskV_-1.0=0.76351225, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54499936, val_rnn_1_1step_R2_maskV_-1.0=0.36660427, val_rnn_1_1step_CC_maskV_-1.0=0.66922659, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:55:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 16.66s\n", + "\u001b[32m2025-05-30 15:55:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.54410589)\n", + "\u001b[32m2025-05-30 15:55:37\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.377, R2_maskV_-1.0=0.623, CC_maskV_-1.0=0.789\n", + "\u001b[32m2025-05-30 15:55:37\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.508, R2_maskV_-1.0=0.424, CC_maskV_-1.0=0.697\n", + "\u001b[32m2025-05-30 15:55:37\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:55:37\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:56:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 120 (stopped at 135 epochs).\n", + "\u001b[32m2025-05-30 15:56:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/136 - loss=1.6474832, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.075927101, MSE_maskV_-1.0=1.6457075, val_loss=1.0614171, val_CC_maskV_-1.0=0.13118091, val_MSE_maskV_-1.0=1.0605365, learning_rate=0.001\n", + "Epoch 15/136 - loss=0.77227277, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47752556, MSE_maskV_-1.0=0.77156866, val_loss=0.80381441, val_CC_maskV_-1.0=0.46518725, val_MSE_maskV_-1.0=0.80264455, learning_rate=0.001\n", + "Epoch 29/136 - loss=0.71456009, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53454572, MSE_maskV_-1.0=0.71396649, val_loss=0.74490249, val_CC_maskV_-1.0=0.52073121, val_MSE_maskV_-1.0=0.74412096, learning_rate=0.001\n", + "Epoch 43/136 - loss=0.68724233, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55834508, MSE_maskV_-1.0=0.68697804, val_loss=0.71867627, val_CC_maskV_-1.0=0.54350168, val_MSE_maskV_-1.0=0.71835893, learning_rate=0.001\n", + "Epoch 57/136 - loss=0.67388678, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57083219, MSE_maskV_-1.0=0.67424196, val_loss=0.7071684, val_CC_maskV_-1.0=0.55110043, val_MSE_maskV_-1.0=0.70735079, learning_rate=0.001\n", + "Epoch 71/136 - loss=0.66653949, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57651967, MSE_maskV_-1.0=0.66675448, val_loss=0.7017501, val_CC_maskV_-1.0=0.55334318, val_MSE_maskV_-1.0=0.70240438, learning_rate=0.001\n", + "Epoch 85/136 - loss=0.65817517, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58354932, MSE_maskV_-1.0=0.65818179, val_loss=0.69148988, val_CC_maskV_-1.0=0.56153566, val_MSE_maskV_-1.0=0.69230175, learning_rate=0.001\n", + "Epoch 99/136 - loss=0.65458256, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5857746, MSE_maskV_-1.0=0.65408319, val_loss=0.68801552, val_CC_maskV_-1.0=0.56451046, val_MSE_maskV_-1.0=0.68854851, learning_rate=0.001\n", + "Epoch 113/136 - loss=0.64980412, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59042364, MSE_maskV_-1.0=0.65207911, val_loss=0.68921858, val_CC_maskV_-1.0=0.5623762, val_MSE_maskV_-1.0=0.69021815, learning_rate=0.001\n", + "Epoch 127/136 - loss=0.6477806, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59172678, MSE_maskV_-1.0=0.64818847, val_loss=0.68603343, val_CC_maskV_-1.0=0.56526083, val_MSE_maskV_-1.0=0.68631721, learning_rate=0.001\n", + "Epoch 136/136 - loss=0.64467651, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59474629, MSE_maskV_-1.0=0.64541119, val_loss=0.67991018, val_CC_maskV_-1.0=0.57022202, val_MSE_maskV_-1.0=0.68034637, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:56:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 35.37s\n", + "\u001b[32m2025-05-30 15:56:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:57:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 175 (stopped at 190 epochs).\n", + "\u001b[32m2025-05-30 15:57:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/191 - loss=1.3539269, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.10255054, MSE_maskV_-1.0=1.3531396, val_loss=1.0260465, val_CC_maskV_-1.0=0.17560832, val_MSE_maskV_-1.0=1.0236906, learning_rate=0.001\n", + "Epoch 21/191 - loss=0.73194504, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51807827, MSE_maskV_-1.0=0.73210067, val_loss=0.76303792, val_CC_maskV_-1.0=0.50599951, val_MSE_maskV_-1.0=0.76155317, learning_rate=0.001\n", + "Epoch 41/191 - loss=0.68756825, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55820382, MSE_maskV_-1.0=0.69115847, val_loss=0.72173136, val_CC_maskV_-1.0=0.5403322, val_MSE_maskV_-1.0=0.72152394, learning_rate=0.001\n", + "Epoch 61/191 - loss=0.67234302, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57234955, MSE_maskV_-1.0=0.67271978, val_loss=0.707802, val_CC_maskV_-1.0=0.55100524, val_MSE_maskV_-1.0=0.70759052, learning_rate=0.001\n", + "Epoch 81/191 - loss=0.66308039, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57959282, MSE_maskV_-1.0=0.66330534, val_loss=0.69075561, val_CC_maskV_-1.0=0.56246388, val_MSE_maskV_-1.0=0.69086748, learning_rate=0.001\n", + "Epoch 101/191 - loss=0.65552837, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58605438, MSE_maskV_-1.0=0.65471923, val_loss=0.68700999, val_CC_maskV_-1.0=0.56469268, val_MSE_maskV_-1.0=0.6869238, learning_rate=0.001\n", + "Epoch 121/191 - loss=0.6504575, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58989692, MSE_maskV_-1.0=0.65048635, val_loss=0.68194699, val_CC_maskV_-1.0=0.56887293, val_MSE_maskV_-1.0=0.68170041, learning_rate=0.001\n", + "Epoch 141/191 - loss=0.64728415, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59247363, MSE_maskV_-1.0=0.64659804, val_loss=0.6797964, val_CC_maskV_-1.0=0.56957412, val_MSE_maskV_-1.0=0.67979598, learning_rate=0.001\n", + "Epoch 161/191 - loss=0.64487731, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59384406, MSE_maskV_-1.0=0.64502448, val_loss=0.68268484, val_CC_maskV_-1.0=0.56778002, val_MSE_maskV_-1.0=0.68245238, learning_rate=0.001\n", + "Epoch 181/191 - loss=0.64320976, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59575671, MSE_maskV_-1.0=0.64391029, val_loss=0.68149555, val_CC_maskV_-1.0=0.56753927, val_MSE_maskV_-1.0=0.68204445, learning_rate=0.001\n", + "Epoch 191/191 - loss=0.64099205, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59674627, MSE_maskV_-1.0=0.64107507, val_loss=0.67875952, val_CC_maskV_-1.0=0.57001495, val_MSE_maskV_-1.0=0.67872411, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:57:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 50.47s\n", + "\u001b[32m2025-05-30 15:57:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.6750105)\n", + "\u001b[32m2025-05-30 15:57:03\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 784us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:57:03\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.637, R2_maskV_-1.0=0.365, CC_maskV_-1.0=0.603\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 704us/step\n", + "51/51 [==============================] - 0s 1ms/step\n", + "84/84 [==============================] - 0s 748us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:57:04\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_Cy1HL64U_ErSV16\" (5/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_Cy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:57:04\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_uAK1HL64U_ErSV16\" (6/16)\n", + "\u001b[32m2025-05-30 15:57:04\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAK1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:57:04\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:57:04\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:57:04\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:57:04\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:57:04\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:57:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:57:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 84 (stopped at 99 epochs).\n", + "\u001b[32m2025-05-30 15:57:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/100 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0022182, rnn_1step_R2_maskV_-1.0=-0.013518281, rnn_1step_CC_maskV_-1.0=0.01570382, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91708964, val_rnn_1step_R2_maskV_-1.0=-0.059144527, val_rnn_1step_CC_maskV_-1.0=0.191254, learning_rate=0.001\n", + "Epoch 11/100 - loss=rnn_1step_loss=0.86588669, rnn_1step_R2_maskV_-1.0=0.12232037, rnn_1step_CC_maskV_-1.0=0.36750326, rnn_1step_MSE_maskV_-1.0=0.86588663, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.77141684, val_rnn_1step_R2_maskV_-1.0=0.10677822, val_rnn_1step_CC_maskV_-1.0=0.41035527, learning_rate=0.001\n", + "Epoch 21/100 - loss=rnn_1step_loss=0.64380062, rnn_1step_R2_maskV_-1.0=0.34398457, rnn_1step_CC_maskV_-1.0=0.59997422, rnn_1step_MSE_maskV_-1.0=0.64380056, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64761037, val_rnn_1step_R2_maskV_-1.0=0.25017011, val_rnn_1step_CC_maskV_-1.0=0.54201269, learning_rate=0.001\n", + "Epoch 31/100 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.45373464, rnn_1step_R2_maskV_-1.0=0.53521949, rnn_1step_CC_maskV_-1.0=0.73921233, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5566594, val_rnn_1step_R2_maskV_-1.0=0.35437045, val_rnn_1step_CC_maskV_-1.0=0.64582849, learning_rate=0.001\n", + "Epoch 41/100 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37076244, rnn_1step_R2_maskV_-1.0=0.61886424, rnn_1step_CC_maskV_-1.0=0.7934292, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51508123, val_rnn_1step_R2_maskV_-1.0=0.40294296, val_rnn_1step_CC_maskV_-1.0=0.68178672, learning_rate=0.001\n", + "Epoch 51/100 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31853747, rnn_1step_R2_maskV_-1.0=0.67244577, rnn_1step_CC_maskV_-1.0=0.82551318, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51123387, val_rnn_1step_R2_maskV_-1.0=0.40724593, val_rnn_1step_CC_maskV_-1.0=0.69037598, learning_rate=0.001\n", + "Epoch 61/100 - loss=rnn_1step_loss=0.28202716, rnn_1step_R2_maskV_-1.0=0.70928526, rnn_1step_CC_maskV_-1.0=0.84784949, rnn_1step_MSE_maskV_-1.0=0.28202718, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4922404, val_rnn_1step_R2_maskV_-1.0=0.43020484, val_rnn_1step_CC_maskV_-1.0=0.70856732, learning_rate=0.001\n", + "Epoch 71/100 - loss=rnn_1step_loss=0.25508389, rnn_1step_R2_maskV_-1.0=0.73727566, rnn_1step_CC_maskV_-1.0=0.8636089, rnn_1step_MSE_maskV_-1.0=0.25508392, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4892551, val_rnn_1step_R2_maskV_-1.0=0.43360159, val_rnn_1step_CC_maskV_-1.0=0.7116735, learning_rate=0.001\n", + "Epoch 81/100 - loss=rnn_1step_loss=0.24157953, rnn_1step_R2_maskV_-1.0=0.75120932, rnn_1step_CC_maskV_-1.0=0.87127548, rnn_1step_MSE_maskV_-1.0=0.24157952, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49314603, val_rnn_1step_R2_maskV_-1.0=0.42909983, val_rnn_1step_CC_maskV_-1.0=0.71367407, learning_rate=0.001\n", + "Epoch 91/100 - loss=rnn_1step_loss=0.22755449, rnn_1step_R2_maskV_-1.0=0.76541197, rnn_1step_CC_maskV_-1.0=0.87942934, rnn_1step_MSE_maskV_-1.0=0.2275545, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50183207, val_rnn_1step_R2_maskV_-1.0=0.41953346, val_rnn_1step_CC_maskV_-1.0=0.71152991, learning_rate=0.001\n", + "Epoch 100/100 - loss=rnn_1step_loss=0.22119021, rnn_1step_R2_maskV_-1.0=0.77210242, rnn_1step_CC_maskV_-1.0=0.88284642, rnn_1step_MSE_maskV_-1.0=0.22119023, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51612133, val_rnn_1step_R2_maskV_-1.0=0.40291107, val_rnn_1step_CC_maskV_-1.0=0.70164764, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:57:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.47s\n", + "\u001b[32m2025-05-30 15:57:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:57:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 86 (stopped at 101 epochs).\n", + "\u001b[32m2025-05-30 15:57:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/102 - loss=rnn_1_1step_loss=1.0019847, rnn_1_1step_R2_maskV_-1.0=-0.013267215, rnn_1_1step_CC_maskV_-1.0=0.067171559, rnn_1_1step_MSE_maskV_-1.0=1.0019848, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91824514, val_rnn_1_1step_R2_maskV_-1.0=-0.060572773, val_rnn_1_1step_CC_maskV_-1.0=0.16047725, learning_rate=0.001\n", + "Epoch 12/102 - loss=rnn_1_1step_loss=0.83488923, rnn_1_1step_R2_maskV_-1.0=0.15059103, rnn_1_1step_CC_maskV_-1.0=0.40892258, rnn_1_1step_MSE_maskV_-1.0=0.83488917, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.77295667, val_rnn_1_1step_R2_maskV_-1.0=0.10288492, val_rnn_1_1step_CC_maskV_-1.0=0.42087957, learning_rate=0.001\n", + "Epoch 23/102 - loss=rnn_1_1step_loss=0.5627293, rnn_1_1step_R2_maskV_-1.0=0.42285639, rnn_1_1step_CC_maskV_-1.0=0.66186398, rnn_1_1step_MSE_maskV_-1.0=0.56272936, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6233725, val_rnn_1_1step_R2_maskV_-1.0=0.27604425, val_rnn_1_1step_CC_maskV_-1.0=0.59148842, learning_rate=0.001\n", + "Epoch 34/102 - loss=rnn_1_1step_loss=0.41834697, rnn_1_1step_R2_maskV_-1.0=0.56890452, rnn_1_1step_CC_maskV_-1.0=0.76244015, rnn_1_1step_MSE_maskV_-1.0=0.418347, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55023271, val_rnn_1_1step_R2_maskV_-1.0=0.35953826, val_rnn_1_1step_CC_maskV_-1.0=0.65508175, learning_rate=0.001\n", + "Epoch 45/102 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.35527781, rnn_1_1step_R2_maskV_-1.0=0.63329387, rnn_1_1step_CC_maskV_-1.0=0.80282462, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52550024, val_rnn_1_1step_R2_maskV_-1.0=0.38882965, val_rnn_1_1step_CC_maskV_-1.0=0.67881477, learning_rate=0.001\n", + "Epoch 56/102 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31582716, rnn_1_1step_R2_maskV_-1.0=0.67373526, rnn_1_1step_CC_maskV_-1.0=0.82779711, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52332836, val_rnn_1_1step_R2_maskV_-1.0=0.39138776, val_rnn_1_1step_CC_maskV_-1.0=0.68722218, learning_rate=0.001\n", + "Epoch 67/102 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.27472374, rnn_1_1step_R2_maskV_-1.0=0.71576786, rnn_1_1step_CC_maskV_-1.0=0.85204202, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52044016, val_rnn_1_1step_R2_maskV_-1.0=0.396047, val_rnn_1_1step_CC_maskV_-1.0=0.69483334, learning_rate=0.001\n", + "Epoch 78/102 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.24750431, rnn_1_1step_R2_maskV_-1.0=0.74446344, rnn_1_1step_CC_maskV_-1.0=0.86789036, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50607514, val_rnn_1_1step_R2_maskV_-1.0=0.4131183, val_rnn_1_1step_CC_maskV_-1.0=0.70438242, learning_rate=0.001\n", + "Epoch 89/102 - loss=rnn_1_1step_loss=0.2310946, rnn_1_1step_R2_maskV_-1.0=0.76141655, rnn_1_1step_CC_maskV_-1.0=0.87752825, rnn_1_1step_MSE_maskV_-1.0=0.23109458, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48902425, val_rnn_1_1step_R2_maskV_-1.0=0.43369132, val_rnn_1_1step_CC_maskV_-1.0=0.71494472, learning_rate=0.001\n", + "Epoch 100/102 - loss=rnn_1_1step_loss=0.21897501, rnn_1_1step_R2_maskV_-1.0=0.77383012, rnn_1_1step_CC_maskV_-1.0=0.88419646, rnn_1_1step_MSE_maskV_-1.0=0.21897502, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51428384, val_rnn_1_1step_R2_maskV_-1.0=0.40466177, val_rnn_1_1step_CC_maskV_-1.0=0.70856249, learning_rate=0.001\n", + "Epoch 102/102 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.21591012, rnn_1_1step_R2_maskV_-1.0=0.77732694, rnn_1_1step_CC_maskV_-1.0=0.88572186, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50172186, val_rnn_1_1step_R2_maskV_-1.0=0.42010841, val_rnn_1_1step_CC_maskV_-1.0=0.71500164, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:57:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 13.83s\n", + "\u001b[32m2025-05-30 15:57:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.48009142)\n", + "\u001b[32m2025-05-30 15:57:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.216, R2_maskV_-1.0=0.784, CC_maskV_-1.0=0.886\n", + "\u001b[32m2025-05-30 15:57:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.421, R2_maskV_-1.0=0.525, CC_maskV_-1.0=0.758\n", + "\u001b[32m2025-05-30 15:57:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:57:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:58:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 175 (stopped at 190 epochs).\n", + "\u001b[32m2025-05-30 15:58:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/191 - loss=1.4466432, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.067796223, MSE_maskV_-1.0=1.4457718, val_loss=1.0546612, val_CC_maskV_-1.0=0.11298986, val_MSE_maskV_-1.0=1.0532757, learning_rate=0.001\n", + "Epoch 21/191 - loss=0.89963973, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3230412, MSE_maskV_-1.0=0.89978337, val_loss=0.9283939, val_CC_maskV_-1.0=0.32140511, val_MSE_maskV_-1.0=0.92535514, learning_rate=0.001\n", + "Epoch 41/191 - loss=0.87613124, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35718828, MSE_maskV_-1.0=0.88068229, val_loss=0.91128778, val_CC_maskV_-1.0=0.34386969, val_MSE_maskV_-1.0=0.90849155, learning_rate=0.001\n", + "Epoch 61/191 - loss=0.86441755, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37301368, MSE_maskV_-1.0=0.86539197, val_loss=0.89666861, val_CC_maskV_-1.0=0.36290076, val_MSE_maskV_-1.0=0.89438105, learning_rate=0.001\n", + "Epoch 81/191 - loss=0.85708731, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38194564, MSE_maskV_-1.0=0.85731971, val_loss=0.88878644, val_CC_maskV_-1.0=0.37212831, val_MSE_maskV_-1.0=0.88718462, learning_rate=0.001\n", + "Epoch 101/191 - loss=0.85219097, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3876119, MSE_maskV_-1.0=0.85136771, val_loss=0.88309729, val_CC_maskV_-1.0=0.37883681, val_MSE_maskV_-1.0=0.88133031, learning_rate=0.001\n", + "Epoch 121/191 - loss=0.84807986, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39248449, MSE_maskV_-1.0=0.84823728, val_loss=0.87811321, val_CC_maskV_-1.0=0.38501847, val_MSE_maskV_-1.0=0.87623948, learning_rate=0.001\n", + "Epoch 141/191 - loss=0.84501082, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39629933, MSE_maskV_-1.0=0.8441087, val_loss=0.87284297, val_CC_maskV_-1.0=0.38981476, val_MSE_maskV_-1.0=0.87141085, learning_rate=0.001\n", + "Epoch 161/191 - loss=0.84231043, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39945066, MSE_maskV_-1.0=0.84220046, val_loss=0.87303948, val_CC_maskV_-1.0=0.3893348, val_MSE_maskV_-1.0=0.87156796, learning_rate=0.001\n", + "Epoch 181/191 - loss=0.8400293, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40227523, MSE_maskV_-1.0=0.84066933, val_loss=0.87052923, val_CC_maskV_-1.0=0.39220485, val_MSE_maskV_-1.0=0.86927891, learning_rate=0.001\n", + "Epoch 191/191 - loss=0.83924961, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40203959, MSE_maskV_-1.0=0.83939767, val_loss=0.86913133, val_CC_maskV_-1.0=0.39411196, val_MSE_maskV_-1.0=0.8679077, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:58:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 44.93s\n", + "\u001b[32m2025-05-30 15:58:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:59:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 175 (stopped at 190 epochs).\n", + "\u001b[32m2025-05-30 15:59:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/191 - loss=1.5552709, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.062263768, MSE_maskV_-1.0=1.5539595, val_loss=1.0823512, val_CC_maskV_-1.0=0.10093367, val_MSE_maskV_-1.0=1.0794514, learning_rate=0.001\n", + "Epoch 21/191 - loss=0.89923334, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.32325694, MSE_maskV_-1.0=0.89938378, val_loss=0.92831671, val_CC_maskV_-1.0=0.32107988, val_MSE_maskV_-1.0=0.92564911, learning_rate=0.001\n", + "Epoch 41/191 - loss=0.87667668, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35612199, MSE_maskV_-1.0=0.88122892, val_loss=0.91190028, val_CC_maskV_-1.0=0.34286371, val_MSE_maskV_-1.0=0.90929216, learning_rate=0.001\n", + "Epoch 61/191 - loss=0.86511129, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3718718, MSE_maskV_-1.0=0.86608917, val_loss=0.89745069, val_CC_maskV_-1.0=0.36194274, val_MSE_maskV_-1.0=0.89521956, learning_rate=0.001\n", + "Epoch 81/191 - loss=0.8577463, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38096008, MSE_maskV_-1.0=0.85798514, val_loss=0.8893972, val_CC_maskV_-1.0=0.37158185, val_MSE_maskV_-1.0=0.88774157, learning_rate=0.001\n", + "Epoch 101/191 - loss=0.8527872, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38685334, MSE_maskV_-1.0=0.85194701, val_loss=0.8835296, val_CC_maskV_-1.0=0.37851861, val_MSE_maskV_-1.0=0.88167924, learning_rate=0.001\n", + "Epoch 121/191 - loss=0.84860504, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39183518, MSE_maskV_-1.0=0.84874994, val_loss=0.87843448, val_CC_maskV_-1.0=0.38481304, val_MSE_maskV_-1.0=0.87649411, learning_rate=0.001\n", + "Epoch 141/191 - loss=0.84547657, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39573604, MSE_maskV_-1.0=0.84457445, val_loss=0.87301338, val_CC_maskV_-1.0=0.3898167, val_MSE_maskV_-1.0=0.87151361, learning_rate=0.001\n", + "Epoch 161/191 - loss=0.8427217, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39896098, MSE_maskV_-1.0=0.84260511, val_loss=0.87312776, val_CC_maskV_-1.0=0.38947329, val_MSE_maskV_-1.0=0.87154967, learning_rate=0.001\n", + "Epoch 181/191 - loss=0.84038556, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40185571, MSE_maskV_-1.0=0.84102803, val_loss=0.87060887, val_CC_maskV_-1.0=0.39235941, val_MSE_maskV_-1.0=0.86924696, learning_rate=0.001\n", + "Epoch 191/191 - loss=0.83959097, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40163741, MSE_maskV_-1.0=0.83973444, val_loss=0.86911356, val_CC_maskV_-1.0=0.39437237, val_MSE_maskV_-1.0=0.86780375, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:59:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 45.17s\n", + "\u001b[32m2025-05-30 15:59:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.86876267)\n", + "\u001b[32m2025-05-30 15:59:06\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 738us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:59:06\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.839, R2_maskV_-1.0=0.161, CC_maskV_-1.0=0.403\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 737us/step\n", + "51/51 [==============================] - 0s 1ms/step\n", + "84/84 [==============================] - 0s 794us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 15:59:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_uAK1HL64U_ErSV16\" (6/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_uAK1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 15:59:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_ACz1HL64U_ErSV16\" (7/16)\n", + "\u001b[32m2025-05-30 15:59:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 15:59:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 15:59:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 15:59:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 15:59:07\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 15:59:07\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 15:59:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 15:59:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 94 (stopped at 109 epochs).\n", + "\u001b[32m2025-05-30 15:59:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/110 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0020238, rnn_1step_R2_maskV_-1.0=-0.013319287, rnn_1step_CC_maskV_-1.0=0.042223006, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91608477, val_rnn_1step_R2_maskV_-1.0=-0.058014601, val_rnn_1step_CC_maskV_-1.0=0.19189124, learning_rate=0.001\n", + "Epoch 12/110 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.84207827, rnn_1step_R2_maskV_-1.0=0.14736174, rnn_1step_CC_maskV_-1.0=0.42135084, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.7613942, val_rnn_1step_R2_maskV_-1.0=0.11545134, val_rnn_1step_CC_maskV_-1.0=0.42176697, learning_rate=0.001\n", + "Epoch 23/110 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.60760611, rnn_1step_R2_maskV_-1.0=0.3811388, rnn_1step_CC_maskV_-1.0=0.6255306, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.67311138, val_rnn_1step_R2_maskV_-1.0=0.21858746, val_rnn_1step_CC_maskV_-1.0=0.53947949, learning_rate=0.001\n", + "Epoch 34/110 - loss=rnn_1step_loss=0.48745689, rnn_1step_R2_maskV_-1.0=0.49983084, rnn_1step_CC_maskV_-1.0=0.71552277, rnn_1step_MSE_maskV_-1.0=0.48745692, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.65694588, val_rnn_1step_R2_maskV_-1.0=0.23607425, val_rnn_1step_CC_maskV_-1.0=0.58542132, learning_rate=0.001\n", + "Epoch 45/110 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.44725481, rnn_1step_R2_maskV_-1.0=0.54048038, rnn_1step_CC_maskV_-1.0=0.74338824, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64239854, val_rnn_1step_R2_maskV_-1.0=0.25218815, val_rnn_1step_CC_maskV_-1.0=0.6040495, learning_rate=0.001\n", + "Epoch 56/110 - loss=rnn_1step_loss=0.42625824, rnn_1step_R2_maskV_-1.0=0.56138808, rnn_1step_CC_maskV_-1.0=0.75747538, rnn_1step_MSE_maskV_-1.0=0.42625827, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63244176, val_rnn_1step_R2_maskV_-1.0=0.26391351, val_rnn_1step_CC_maskV_-1.0=0.61225146, learning_rate=0.001\n", + "Epoch 67/110 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41260967, rnn_1step_R2_maskV_-1.0=0.57527602, rnn_1step_CC_maskV_-1.0=0.76626933, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.67396015, val_rnn_1step_R2_maskV_-1.0=0.21480946, val_rnn_1step_CC_maskV_-1.0=0.60178071, learning_rate=0.001\n", + "Epoch 78/110 - loss=rnn_1step_loss=0.4059101, rnn_1step_R2_maskV_-1.0=0.58160329, rnn_1step_CC_maskV_-1.0=0.77192813, rnn_1step_MSE_maskV_-1.0=0.40591007, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60274476, val_rnn_1step_R2_maskV_-1.0=0.29898831, val_rnn_1step_CC_maskV_-1.0=0.63247323, learning_rate=0.001\n", + "Epoch 89/110 - loss=rnn_1step_loss=0.39720795, rnn_1step_R2_maskV_-1.0=0.5906868, rnn_1step_CC_maskV_-1.0=0.77816725, rnn_1step_MSE_maskV_-1.0=0.39720798, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62382942, val_rnn_1step_R2_maskV_-1.0=0.27414644, val_rnn_1step_CC_maskV_-1.0=0.62262201, learning_rate=0.001\n", + "Epoch 100/110 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38396534, rnn_1step_R2_maskV_-1.0=0.60384381, rnn_1step_CC_maskV_-1.0=0.78456116, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5900982, val_rnn_1step_R2_maskV_-1.0=0.31337458, val_rnn_1step_CC_maskV_-1.0=0.6413368, learning_rate=0.001\n", + "Epoch 110/110 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37358907, rnn_1step_R2_maskV_-1.0=0.61425543, rnn_1step_CC_maskV_-1.0=0.79151779, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60156131, val_rnn_1step_R2_maskV_-1.0=0.30001807, val_rnn_1step_CC_maskV_-1.0=0.63675803, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:59:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.32s\n", + "\u001b[32m2025-05-30 15:59:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 15:59:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 103 (stopped at 118 epochs).\n", + "\u001b[32m2025-05-30 15:59:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/119 - loss=rnn_1_1step_loss=1.0024239, rnn_1_1step_R2_maskV_-1.0=-0.013737235, rnn_1_1step_CC_maskV_-1.0=0.0065332558, rnn_1_1step_MSE_maskV_-1.0=1.0024238, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91741782, val_rnn_1_1step_R2_maskV_-1.0=-0.059605062, val_rnn_1_1step_CC_maskV_-1.0=0.21901385, learning_rate=0.001\n", + "Epoch 13/119 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.79554462, rnn_1_1step_R2_maskV_-1.0=0.19260466, rnn_1_1step_CC_maskV_-1.0=0.45784545, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.76046294, val_rnn_1_1step_R2_maskV_-1.0=0.11504921, val_rnn_1_1step_CC_maskV_-1.0=0.41610414, learning_rate=0.001\n", + "Epoch 25/119 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.57364064, rnn_1_1step_R2_maskV_-1.0=0.41426826, rnn_1_1step_CC_maskV_-1.0=0.65193081, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65333551, val_rnn_1_1step_R2_maskV_-1.0=0.24410588, val_rnn_1_1step_CC_maskV_-1.0=0.55553859, learning_rate=0.001\n", + "Epoch 37/119 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.51233011, rnn_1_1step_R2_maskV_-1.0=0.47506344, rnn_1_1step_CC_maskV_-1.0=0.69787061, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63721114, val_rnn_1_1step_R2_maskV_-1.0=0.2636013, val_rnn_1_1step_CC_maskV_-1.0=0.58268958, learning_rate=0.001\n", + "Epoch 49/119 - loss=rnn_1_1step_loss=0.46878776, rnn_1_1step_R2_maskV_-1.0=0.51891559, rnn_1_1step_CC_maskV_-1.0=0.72844166, rnn_1_1step_MSE_maskV_-1.0=0.4687877, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65236878, val_rnn_1_1step_R2_maskV_-1.0=0.24446073, val_rnn_1_1step_CC_maskV_-1.0=0.58530253, learning_rate=0.001\n", + "Epoch 61/119 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.43197227, rnn_1_1step_R2_maskV_-1.0=0.55584115, rnn_1_1step_CC_maskV_-1.0=0.75327832, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63777041, val_rnn_1_1step_R2_maskV_-1.0=0.25898331, val_rnn_1_1step_CC_maskV_-1.0=0.60570234, learning_rate=0.001\n", + "Epoch 73/119 - loss=rnn_1_1step_loss=0.39562955, rnn_1_1step_R2_maskV_-1.0=0.59230173, rnn_1_1step_CC_maskV_-1.0=0.77747691, rnn_1_1step_MSE_maskV_-1.0=0.39562958, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5963915, val_rnn_1_1step_R2_maskV_-1.0=0.30604976, val_rnn_1_1step_CC_maskV_-1.0=0.63818634, learning_rate=0.001\n", + "Epoch 85/119 - loss=rnn_1_1step_loss=0.37364769, rnn_1_1step_R2_maskV_-1.0=0.6143387, rnn_1_1step_CC_maskV_-1.0=0.79161698, rnn_1_1step_MSE_maskV_-1.0=0.37364766, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58019882, val_rnn_1_1step_R2_maskV_-1.0=0.32537854, val_rnn_1_1step_CC_maskV_-1.0=0.64979398, learning_rate=0.001\n", + "Epoch 97/119 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36709228, rnn_1_1step_R2_maskV_-1.0=0.62143332, rnn_1_1step_CC_maskV_-1.0=0.79623401, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5242486, val_rnn_1_1step_R2_maskV_-1.0=0.39095062, val_rnn_1_1step_CC_maskV_-1.0=0.67956203, learning_rate=0.001\n", + "Epoch 109/119 - loss=rnn_1_1step_loss=0.34493086, rnn_1_1step_R2_maskV_-1.0=0.64376998, rnn_1_1step_CC_maskV_-1.0=0.80940634, rnn_1_1step_MSE_maskV_-1.0=0.34493089, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55538529, val_rnn_1_1step_R2_maskV_-1.0=0.35554606, val_rnn_1_1step_CC_maskV_-1.0=0.66773731, learning_rate=0.001\n", + "Epoch 119/119 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33334842, rnn_1_1step_R2_maskV_-1.0=0.65585774, rnn_1_1step_CC_maskV_-1.0=0.81647491, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55691546, val_rnn_1_1step_R2_maskV_-1.0=0.35432029, val_rnn_1_1step_CC_maskV_-1.0=0.67278755, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 15:59:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.50s\n", + "\u001b[32m2025-05-30 15:59:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.49230149)\n", + "\u001b[32m2025-05-30 15:59:40\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.333, R2_maskV_-1.0=0.667, CC_maskV_-1.0=0.818\n", + "\u001b[32m2025-05-30 15:59:40\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.467, R2_maskV_-1.0=0.472, CC_maskV_-1.0=0.72\n", + "\u001b[32m2025-05-30 15:59:40\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 15:59:40\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:00:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 141 (stopped at 156 epochs).\n", + "\u001b[32m2025-05-30 16:00:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/157 - loss=2.2358847, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.05658602, MSE_maskV_-1.0=2.2332067, val_loss=1.2275531, val_CC_maskV_-1.0=0.13311636, val_MSE_maskV_-1.0=1.220878, learning_rate=0.001\n", + "Epoch 17/157 - loss=0.78499621, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46430156, MSE_maskV_-1.0=0.784805, val_loss=0.80326986, val_CC_maskV_-1.0=0.46791178, val_MSE_maskV_-1.0=0.80185986, learning_rate=0.001\n", + "Epoch 33/157 - loss=0.75062346, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50030184, MSE_maskV_-1.0=0.75052953, val_loss=0.77335048, val_CC_maskV_-1.0=0.49818757, val_MSE_maskV_-1.0=0.77152288, learning_rate=0.001\n", + "Epoch 49/157 - loss=0.73574066, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51460248, MSE_maskV_-1.0=0.73594767, val_loss=0.76183724, val_CC_maskV_-1.0=0.50852948, val_MSE_maskV_-1.0=0.75960726, learning_rate=0.001\n", + "Epoch 65/157 - loss=0.72802961, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52100766, MSE_maskV_-1.0=0.72752625, val_loss=0.75211996, val_CC_maskV_-1.0=0.5169186, val_MSE_maskV_-1.0=0.75095016, learning_rate=0.001\n", + "Epoch 81/157 - loss=0.72267497, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52687484, MSE_maskV_-1.0=0.72280908, val_loss=0.74544913, val_CC_maskV_-1.0=0.52359891, val_MSE_maskV_-1.0=0.7438094, learning_rate=0.001\n", + "Epoch 97/157 - loss=0.71933621, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52946633, MSE_maskV_-1.0=0.71968031, val_loss=0.74269378, val_CC_maskV_-1.0=0.52490741, val_MSE_maskV_-1.0=0.74146676, learning_rate=0.001\n", + "Epoch 113/157 - loss=0.71685135, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53106254, MSE_maskV_-1.0=0.72012544, val_loss=0.74189651, val_CC_maskV_-1.0=0.52644378, val_MSE_maskV_-1.0=0.74021697, learning_rate=0.001\n", + "Epoch 129/157 - loss=0.71554619, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53251749, MSE_maskV_-1.0=0.71574241, val_loss=0.73848844, val_CC_maskV_-1.0=0.5289079, val_MSE_maskV_-1.0=0.73700476, learning_rate=0.001\n", + "Epoch 145/157 - loss=0.71394479, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53348744, MSE_maskV_-1.0=0.71360844, val_loss=0.73940438, val_CC_maskV_-1.0=0.52873868, val_MSE_maskV_-1.0=0.7375071, learning_rate=0.001\n", + "Epoch 157/157 - loss=0.71319187, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53521156, MSE_maskV_-1.0=0.71292591, val_loss=0.73795146, val_CC_maskV_-1.0=0.53005677, val_MSE_maskV_-1.0=0.73638123, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:00:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 37.98s\n", + "\u001b[32m2025-05-30 16:00:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:00:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 141 (stopped at 156 epochs).\n", + "\u001b[32m2025-05-30 16:00:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/157 - loss=2.4550586, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.068173625, MSE_maskV_-1.0=2.4517725, val_loss=1.2481105, val_CC_maskV_-1.0=0.11825781, val_MSE_maskV_-1.0=1.2440863, learning_rate=0.001\n", + "Epoch 17/157 - loss=0.78669083, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46279916, MSE_maskV_-1.0=0.78650594, val_loss=0.80513388, val_CC_maskV_-1.0=0.46576202, val_MSE_maskV_-1.0=0.80364472, learning_rate=0.001\n", + "Epoch 33/157 - loss=0.75010931, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50105524, MSE_maskV_-1.0=0.74999398, val_loss=0.7729615, val_CC_maskV_-1.0=0.4986541, val_MSE_maskV_-1.0=0.77108675, learning_rate=0.001\n", + "Epoch 49/157 - loss=0.73478961, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.515625, MSE_maskV_-1.0=0.73501331, val_loss=0.76073182, val_CC_maskV_-1.0=0.50964659, val_MSE_maskV_-1.0=0.7584883, learning_rate=0.001\n", + "Epoch 65/157 - loss=0.72716749, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52193254, MSE_maskV_-1.0=0.72666597, val_loss=0.75107789, val_CC_maskV_-1.0=0.5179534, val_MSE_maskV_-1.0=0.74988669, learning_rate=0.001\n", + "Epoch 81/157 - loss=0.72202426, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52750212, MSE_maskV_-1.0=0.72214878, val_loss=0.74462175, val_CC_maskV_-1.0=0.52431506, val_MSE_maskV_-1.0=0.74300903, learning_rate=0.001\n", + "Epoch 97/157 - loss=0.71886516, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52991432, MSE_maskV_-1.0=0.71920049, val_loss=0.74200755, val_CC_maskV_-1.0=0.52553684, val_MSE_maskV_-1.0=0.74078959, learning_rate=0.001\n", + "Epoch 113/157 - loss=0.71650702, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53136986, MSE_maskV_-1.0=0.71978742, val_loss=0.7414003, val_CC_maskV_-1.0=0.52686906, val_MSE_maskV_-1.0=0.73974168, learning_rate=0.001\n", + "Epoch 129/157 - loss=0.71529347, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53274179, MSE_maskV_-1.0=0.71549249, val_loss=0.73814344, val_CC_maskV_-1.0=0.52919567, val_MSE_maskV_-1.0=0.73667383, learning_rate=0.001\n", + "Epoch 145/157 - loss=0.71376264, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53366733, MSE_maskV_-1.0=0.7134198, val_loss=0.73911929, val_CC_maskV_-1.0=0.52898836, val_MSE_maskV_-1.0=0.73722655, learning_rate=0.001\n", + "Epoch 157/157 - loss=0.71305192, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.535353, MSE_maskV_-1.0=0.71277738, val_loss=0.73773938, val_CC_maskV_-1.0=0.53021908, val_MSE_maskV_-1.0=0.73618251, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:00:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 38.08s\n", + "\u001b[32m2025-05-30 16:00:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.7364614)\n", + "\u001b[32m2025-05-30 16:00:56\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 779us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:00:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.713, R2_maskV_-1.0=0.288, CC_maskV_-1.0=0.536\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 742us/step\n", + "51/51 [==============================] - 0s 722us/step\n", + "84/84 [==============================] - 0s 671us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:00:57\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_ACz1HL64U_ErSV16\" (7/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_ACz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:00:57\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_ACy1HL64U_ErSV16\" (8/16)\n", + "\u001b[32m2025-05-30 16:00:57\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:00:57\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:00:57\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:00:57\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:00:57\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:00:57\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:00:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:01:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 118 (stopped at 133 epochs).\n", + "\u001b[32m2025-05-30 16:01:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/134 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0007449, rnn_1step_R2_maskV_-1.0=-0.011898246, rnn_1step_CC_maskV_-1.0=0.048859797, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91257161, val_rnn_1step_R2_maskV_-1.0=-0.054232836, val_rnn_1step_CC_maskV_-1.0=0.16016059, learning_rate=0.001\n", + "Epoch 15/134 - loss=rnn_1step_loss=0.71774626, rnn_1step_R2_maskV_-1.0=0.27114862, rnn_1step_CC_maskV_-1.0=0.53702235, rnn_1step_MSE_maskV_-1.0=0.71774632, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.70478481, val_rnn_1step_R2_maskV_-1.0=0.18154669, val_rnn_1step_CC_maskV_-1.0=0.4862248, learning_rate=0.001\n", + "Epoch 29/134 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.5607698, rnn_1step_R2_maskV_-1.0=0.4265855, rnn_1step_CC_maskV_-1.0=0.66208827, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64698768, val_rnn_1step_R2_maskV_-1.0=0.24984179, val_rnn_1step_CC_maskV_-1.0=0.56378728, learning_rate=0.001\n", + "Epoch 43/134 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.49726164, rnn_1step_R2_maskV_-1.0=0.48914817, rnn_1step_CC_maskV_-1.0=0.70850402, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63751799, val_rnn_1step_R2_maskV_-1.0=0.26098174, val_rnn_1step_CC_maskV_-1.0=0.59048319, learning_rate=0.001\n", + "Epoch 57/134 - loss=rnn_1step_loss=0.44151306, rnn_1step_R2_maskV_-1.0=0.54554838, rnn_1step_CC_maskV_-1.0=0.7467609, rnn_1step_MSE_maskV_-1.0=0.44151303, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60249746, val_rnn_1step_R2_maskV_-1.0=0.30064642, val_rnn_1step_CC_maskV_-1.0=0.62030011, learning_rate=0.001\n", + "Epoch 71/134 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4111028, rnn_1step_R2_maskV_-1.0=0.57609612, rnn_1step_CC_maskV_-1.0=0.76721722, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59980369, val_rnn_1step_R2_maskV_-1.0=0.30354041, val_rnn_1step_CC_maskV_-1.0=0.63083756, learning_rate=0.001\n", + "Epoch 85/134 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39717054, rnn_1step_R2_maskV_-1.0=0.59051907, rnn_1step_CC_maskV_-1.0=0.77641284, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59482533, val_rnn_1step_R2_maskV_-1.0=0.30923972, val_rnn_1step_CC_maskV_-1.0=0.63451856, learning_rate=0.001\n", + "Epoch 99/134 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3916018, rnn_1step_R2_maskV_-1.0=0.59660625, rnn_1step_CC_maskV_-1.0=0.78099275, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61332494, val_rnn_1step_R2_maskV_-1.0=0.28662735, val_rnn_1step_CC_maskV_-1.0=0.63299072, learning_rate=0.001\n", + "Epoch 113/134 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37455544, rnn_1step_R2_maskV_-1.0=0.61340249, rnn_1step_CC_maskV_-1.0=0.79086876, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60532182, val_rnn_1step_R2_maskV_-1.0=0.29673755, val_rnn_1step_CC_maskV_-1.0=0.63480216, learning_rate=0.001\n", + "Epoch 127/134 - loss=rnn_1step_loss=0.36621681, rnn_1step_R2_maskV_-1.0=0.62169576, rnn_1step_CC_maskV_-1.0=0.79654187, rnn_1step_MSE_maskV_-1.0=0.36621678, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54582244, val_rnn_1step_R2_maskV_-1.0=0.36690775, val_rnn_1step_CC_maskV_-1.0=0.66136152, learning_rate=0.001\n", + "Epoch 134/134 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35694501, rnn_1step_R2_maskV_-1.0=0.63143826, rnn_1step_CC_maskV_-1.0=0.80195594, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57474047, val_rnn_1step_R2_maskV_-1.0=0.33270031, val_rnn_1step_CC_maskV_-1.0=0.65152496, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:01:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.82s\n", + "\u001b[32m2025-05-30 16:01:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:01:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 72 (stopped at 87 epochs).\n", + "\u001b[32m2025-05-30 16:01:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/88 - loss=rnn_1_1step_loss=0.99776059, rnn_1_1step_R2_maskV_-1.0=-0.0090872869, rnn_1_1step_CC_maskV_-1.0=0.11143172, rnn_1_1step_MSE_maskV_-1.0=0.99776065, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91121483, val_rnn_1_1step_R2_maskV_-1.0=-0.05255495, val_rnn_1_1step_CC_maskV_-1.0=0.17303647, learning_rate=0.001\n", + "Epoch 10/88 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.86692446, rnn_1_1step_R2_maskV_-1.0=0.12279832, rnn_1_1step_CC_maskV_-1.0=0.43352634, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.79321283, val_rnn_1_1step_R2_maskV_-1.0=0.081077278, val_rnn_1_1step_CC_maskV_-1.0=0.39428666, learning_rate=0.001\n", + "Epoch 19/88 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.665106, rnn_1_1step_R2_maskV_-1.0=0.32302952, rnn_1_1step_CC_maskV_-1.0=0.57919872, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.66738158, val_rnn_1_1step_R2_maskV_-1.0=0.22502832, val_rnn_1_1step_CC_maskV_-1.0=0.53124738, learning_rate=0.001\n", + "Epoch 28/88 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.56530768, rnn_1_1step_R2_maskV_-1.0=0.42298871, rnn_1_1step_CC_maskV_-1.0=0.65904844, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62511379, val_rnn_1_1step_R2_maskV_-1.0=0.27389044, val_rnn_1_1step_CC_maskV_-1.0=0.57741052, learning_rate=0.001\n", + "Epoch 37/88 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.50951678, rnn_1_1step_R2_maskV_-1.0=0.47801888, rnn_1_1step_CC_maskV_-1.0=0.69997221, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62240958, val_rnn_1_1step_R2_maskV_-1.0=0.27763665, val_rnn_1_1step_CC_maskV_-1.0=0.59648675, learning_rate=0.001\n", + "Epoch 46/88 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.45436177, rnn_1_1step_R2_maskV_-1.0=0.5336104, rnn_1_1step_CC_maskV_-1.0=0.73854256, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60276479, val_rnn_1_1step_R2_maskV_-1.0=0.29975969, val_rnn_1_1step_CC_maskV_-1.0=0.621737, learning_rate=0.001\n", + "Epoch 55/88 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41994253, rnn_1_1step_R2_maskV_-1.0=0.56846917, rnn_1_1step_CC_maskV_-1.0=0.76153034, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60194397, val_rnn_1_1step_R2_maskV_-1.0=0.3001439, val_rnn_1_1step_CC_maskV_-1.0=0.62941438, learning_rate=0.001\n", + "Epoch 64/88 - loss=rnn_1_1step_loss=0.40421954, rnn_1_1step_R2_maskV_-1.0=0.58416021, rnn_1_1step_CC_maskV_-1.0=0.77256036, rnn_1_1step_MSE_maskV_-1.0=0.40421951, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55559343, val_rnn_1_1step_R2_maskV_-1.0=0.35515964, val_rnn_1_1step_CC_maskV_-1.0=0.65234673, learning_rate=0.001\n", + "Epoch 73/88 - loss=rnn_1_1step_loss=0.39161739, rnn_1_1step_R2_maskV_-1.0=0.59707093, rnn_1_1step_CC_maskV_-1.0=0.78092271, rnn_1_1step_MSE_maskV_-1.0=0.39161736, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58175844, val_rnn_1_1step_R2_maskV_-1.0=0.32485852, val_rnn_1_1step_CC_maskV_-1.0=0.63967687, learning_rate=0.001\n", + "Epoch 82/88 - loss=rnn_1_1step_loss=0.37679279, rnn_1_1step_R2_maskV_-1.0=0.61175179, rnn_1_1step_CC_maskV_-1.0=0.78933614, rnn_1_1step_MSE_maskV_-1.0=0.37679282, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57491565, val_rnn_1_1step_R2_maskV_-1.0=0.33286384, val_rnn_1_1step_CC_maskV_-1.0=0.64479393, learning_rate=0.001\n", + "Epoch 88/88 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.37023988, rnn_1_1step_R2_maskV_-1.0=0.61858618, rnn_1_1step_CC_maskV_-1.0=0.79408002, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57213718, val_rnn_1_1step_R2_maskV_-1.0=0.3363018, val_rnn_1_1step_CC_maskV_-1.0=0.6507386, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:01:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 11.24s\n", + "\u001b[32m2025-05-30 16:01:25\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.53103119)\n", + "\u001b[32m2025-05-30 16:01:26\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.362, R2_maskV_-1.0=0.638, CC_maskV_-1.0=0.8\n", + "\u001b[32m2025-05-30 16:01:26\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.515, R2_maskV_-1.0=0.418, CC_maskV_-1.0=0.681\n", + "\u001b[32m2025-05-30 16:01:26\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:01:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:02:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 172 (stopped at 187 epochs).\n", + "\u001b[32m2025-05-30 16:02:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/188 - loss=1.021807, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.19505969, MSE_maskV_-1.0=1.0218734, val_loss=0.94127893, val_CC_maskV_-1.0=0.29364392, val_MSE_maskV_-1.0=0.93828493, learning_rate=0.001\n", + "Epoch 20/188 - loss=0.66081452, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58090019, MSE_maskV_-1.0=0.66081709, val_loss=0.69875121, val_CC_maskV_-1.0=0.55851948, val_MSE_maskV_-1.0=0.69734156, learning_rate=0.001\n", + "Epoch 39/188 - loss=0.63714236, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60013855, MSE_maskV_-1.0=0.63704056, val_loss=0.6821782, val_CC_maskV_-1.0=0.5712353, val_MSE_maskV_-1.0=0.68118703, learning_rate=0.001\n", + "Epoch 58/188 - loss=0.6236071, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61086148, MSE_maskV_-1.0=0.62345064, val_loss=0.67419314, val_CC_maskV_-1.0=0.57741421, val_MSE_maskV_-1.0=0.67324114, learning_rate=0.001\n", + "Epoch 77/188 - loss=0.61562157, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61671156, MSE_maskV_-1.0=0.61522681, val_loss=0.66623032, val_CC_maskV_-1.0=0.58358949, val_MSE_maskV_-1.0=0.66537172, learning_rate=0.001\n", + "Epoch 96/188 - loss=0.60947365, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62172586, MSE_maskV_-1.0=0.60953969, val_loss=0.66467369, val_CC_maskV_-1.0=0.58391839, val_MSE_maskV_-1.0=0.66423953, learning_rate=0.001\n", + "Epoch 115/188 - loss=0.60463738, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62511951, MSE_maskV_-1.0=0.60481018, val_loss=0.66036552, val_CC_maskV_-1.0=0.5879212, val_MSE_maskV_-1.0=0.65991819, learning_rate=0.001\n", + "Epoch 134/188 - loss=0.60099834, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62895608, MSE_maskV_-1.0=0.60254288, val_loss=0.65852016, val_CC_maskV_-1.0=0.58904797, val_MSE_maskV_-1.0=0.65815765, learning_rate=0.001\n", + "Epoch 153/188 - loss=0.59736335, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6314733, MSE_maskV_-1.0=0.59800756, val_loss=0.65467662, val_CC_maskV_-1.0=0.592094, val_MSE_maskV_-1.0=0.65471673, learning_rate=0.001\n", + "Epoch 172/188 - loss=0.5948891, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6335296, MSE_maskV_-1.0=0.59549856, val_loss=0.65136939, val_CC_maskV_-1.0=0.59563208, val_MSE_maskV_-1.0=0.6507616, learning_rate=0.001\n", + "Epoch 188/188 - loss=0.59274048, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63503188, MSE_maskV_-1.0=0.59201711, val_loss=0.6524784, val_CC_maskV_-1.0=0.59387571, val_MSE_maskV_-1.0=0.65225893, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:02:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 48.16s\n", + "\u001b[32m2025-05-30 16:02:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:02:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 141 (stopped at 156 epochs).\n", + "\u001b[32m2025-05-30 16:02:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/157 - loss=1.0426836, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.18718311, MSE_maskV_-1.0=1.0427076, val_loss=0.92535228, val_CC_maskV_-1.0=0.30981338, val_MSE_maskV_-1.0=0.92342943, learning_rate=0.001\n", + "Epoch 17/157 - loss=0.67063034, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57297051, MSE_maskV_-1.0=0.67050785, val_loss=0.70598698, val_CC_maskV_-1.0=0.54999787, val_MSE_maskV_-1.0=0.70595777, learning_rate=0.001\n", + "Epoch 33/157 - loss=0.63767523, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60000634, MSE_maskV_-1.0=0.637685, val_loss=0.68069917, val_CC_maskV_-1.0=0.57102221, val_MSE_maskV_-1.0=0.68084359, learning_rate=0.001\n", + "Epoch 49/157 - loss=0.62290496, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61173308, MSE_maskV_-1.0=0.62309754, val_loss=0.66949624, val_CC_maskV_-1.0=0.57943743, val_MSE_maskV_-1.0=0.66947031, learning_rate=0.001\n", + "Epoch 65/157 - loss=0.61429375, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61800289, MSE_maskV_-1.0=0.61396003, val_loss=0.66001385, val_CC_maskV_-1.0=0.58611929, val_MSE_maskV_-1.0=0.6607877, learning_rate=0.001\n", + "Epoch 81/157 - loss=0.60820895, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62347555, MSE_maskV_-1.0=0.60827059, val_loss=0.65549129, val_CC_maskV_-1.0=0.59059972, val_MSE_maskV_-1.0=0.65594298, learning_rate=0.001\n", + "Epoch 97/157 - loss=0.60335368, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62729114, MSE_maskV_-1.0=0.60395861, val_loss=0.65499127, val_CC_maskV_-1.0=0.59071016, val_MSE_maskV_-1.0=0.65540051, learning_rate=0.001\n", + "Epoch 113/157 - loss=0.59993523, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63010472, MSE_maskV_-1.0=0.60111052, val_loss=0.65335816, val_CC_maskV_-1.0=0.59241182, val_MSE_maskV_-1.0=0.65375906, learning_rate=0.001\n", + "Epoch 129/157 - loss=0.5967018, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63156766, MSE_maskV_-1.0=0.59697473, val_loss=0.65063483, val_CC_maskV_-1.0=0.59398609, val_MSE_maskV_-1.0=0.65124226, learning_rate=0.001\n", + "Epoch 145/157 - loss=0.59422916, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63312274, MSE_maskV_-1.0=0.59411937, val_loss=0.64952791, val_CC_maskV_-1.0=0.59577006, val_MSE_maskV_-1.0=0.64982408, learning_rate=0.001\n", + "Epoch 157/157 - loss=0.59253937, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63525164, MSE_maskV_-1.0=0.59251964, val_loss=0.65014929, val_CC_maskV_-1.0=0.59479433, val_MSE_maskV_-1.0=0.65083361, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:02:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 40.66s\n", + "\u001b[32m2025-05-30 16:02:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.64803642)\n", + "\u001b[32m2025-05-30 16:02:55\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 786us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:02:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.592, R2_maskV_-1.0=0.411, CC_maskV_-1.0=0.639\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 776us/step\n", + "51/51 [==============================] - 0s 779us/step\n", + "84/84 [==============================] - 0s 696us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:02:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_ACy1HL64U_ErSV16\" (8/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_ACy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:02:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_KCz1HL64U_ErSV16\" (9/16)\n", + "\u001b[32m2025-05-30 16:02:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:02:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:02:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:02:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:02:56\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:02:56\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:02:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:03:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 133 (stopped at 148 epochs).\n", + "\u001b[32m2025-05-30 16:03:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.00237, rnn_1step_R2_maskV_-1.0=-0.013697315, rnn_1step_CC_maskV_-1.0=0.011909612, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91817254, val_rnn_1step_R2_maskV_-1.0=-0.06042479, val_rnn_1step_CC_maskV_-1.0=0.27443671, learning_rate=0.001\n", + "Epoch 16/149 - loss=rnn_1step_loss=0.71718484, rnn_1step_R2_maskV_-1.0=0.26854074, rnn_1step_CC_maskV_-1.0=0.53415507, rnn_1step_MSE_maskV_-1.0=0.7171849, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.70026493, val_rnn_1step_R2_maskV_-1.0=0.18853085, val_rnn_1step_CC_maskV_-1.0=0.49780777, learning_rate=0.001\n", + "Epoch 31/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.57620651, rnn_1step_R2_maskV_-1.0=0.40957174, rnn_1step_CC_maskV_-1.0=0.65204245, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.65291309, val_rnn_1step_R2_maskV_-1.0=0.24220425, val_rnn_1step_CC_maskV_-1.0=0.55300373, learning_rate=0.001\n", + "Epoch 46/149 - loss=rnn_1step_loss=0.48607671, rnn_1step_R2_maskV_-1.0=0.5006215, rnn_1step_CC_maskV_-1.0=0.71705127, rnn_1step_MSE_maskV_-1.0=0.48607668, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62188107, val_rnn_1step_R2_maskV_-1.0=0.27855137, val_rnn_1step_CC_maskV_-1.0=0.59563774, learning_rate=0.001\n", + "Epoch 61/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39262965, rnn_1step_R2_maskV_-1.0=0.59603417, rnn_1step_CC_maskV_-1.0=0.77959031, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57641381, val_rnn_1step_R2_maskV_-1.0=0.33022654, val_rnn_1step_CC_maskV_-1.0=0.64597428, learning_rate=0.001\n", + "Epoch 76/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32013083, rnn_1step_R2_maskV_-1.0=0.6699062, rnn_1step_CC_maskV_-1.0=0.82459462, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54923743, val_rnn_1step_R2_maskV_-1.0=0.36213285, val_rnn_1step_CC_maskV_-1.0=0.67541236, learning_rate=0.001\n", + "Epoch 91/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27438381, rnn_1step_R2_maskV_-1.0=0.71711397, rnn_1step_CC_maskV_-1.0=0.85183424, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54232675, val_rnn_1step_R2_maskV_-1.0=0.36912596, val_rnn_1step_CC_maskV_-1.0=0.6835416, learning_rate=0.001\n", + "Epoch 106/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.24351722, rnn_1step_R2_maskV_-1.0=0.74890518, rnn_1step_CC_maskV_-1.0=0.86977208, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.513596, val_rnn_1step_R2_maskV_-1.0=0.40318668, val_rnn_1step_CC_maskV_-1.0=0.70118386, learning_rate=0.001\n", + "Epoch 121/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.20231187, rnn_1step_R2_maskV_-1.0=0.79122293, rnn_1step_CC_maskV_-1.0=0.89331955, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51753592, val_rnn_1step_R2_maskV_-1.0=0.39753675, val_rnn_1step_CC_maskV_-1.0=0.70523041, learning_rate=0.001\n", + "Epoch 136/149 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.18635631, rnn_1step_R2_maskV_-1.0=0.80720484, rnn_1step_CC_maskV_-1.0=0.90239125, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50680828, val_rnn_1step_R2_maskV_-1.0=0.41034156, val_rnn_1step_CC_maskV_-1.0=0.71155071, learning_rate=0.001\n", + "Epoch 149/149 - loss=rnn_1step_loss=0.17479336, rnn_1step_R2_maskV_-1.0=0.81920254, rnn_1step_CC_maskV_-1.0=0.90861779, rnn_1step_MSE_maskV_-1.0=0.17479338, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51309222, val_rnn_1step_R2_maskV_-1.0=0.40285152, val_rnn_1step_CC_maskV_-1.0=0.70994234, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:03:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 16.87s\n", + "\u001b[32m2025-05-30 16:03:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:03:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 99 (stopped at 114 epochs).\n", + "\u001b[32m2025-05-30 16:03:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.002359, rnn_1_1step_R2_maskV_-1.0=-0.013685253, rnn_1_1step_CC_maskV_-1.0=0.021603696, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91798133, val_rnn_1_1step_R2_maskV_-1.0=-0.060195193, val_rnn_1_1step_CC_maskV_-1.0=0.2464458, learning_rate=0.001\n", + "Epoch 13/115 - loss=rnn_1_1step_loss=0.79280931, rnn_1_1step_R2_maskV_-1.0=0.19392589, rnn_1_1step_CC_maskV_-1.0=0.45837182, rnn_1_1step_MSE_maskV_-1.0=0.79280937, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.73115373, val_rnn_1_1step_R2_maskV_-1.0=0.15257974, val_rnn_1_1step_CC_maskV_-1.0=0.44536898, learning_rate=0.001\n", + "Epoch 25/115 - loss=rnn_1_1step_loss=0.59903997, rnn_1_1step_R2_maskV_-1.0=0.38687947, rnn_1_1step_CC_maskV_-1.0=0.63406682, rnn_1_1step_MSE_maskV_-1.0=0.59903991, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65510637, val_rnn_1_1step_R2_maskV_-1.0=0.23975867, val_rnn_1_1step_CC_maskV_-1.0=0.54999822, learning_rate=0.001\n", + "Epoch 37/115 - loss=rnn_1_1step_loss=0.49913394, rnn_1_1step_R2_maskV_-1.0=0.49000368, rnn_1_1step_CC_maskV_-1.0=0.70842701, rnn_1_1step_MSE_maskV_-1.0=0.49913391, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63079429, val_rnn_1_1step_R2_maskV_-1.0=0.26947406, val_rnn_1_1step_CC_maskV_-1.0=0.58302492, learning_rate=0.001\n", + "Epoch 49/115 - loss=rnn_1_1step_loss=0.40137649, rnn_1_1step_R2_maskV_-1.0=0.58912402, rnn_1_1step_CC_maskV_-1.0=0.774001, rnn_1_1step_MSE_maskV_-1.0=0.40137646, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59069639, val_rnn_1_1step_R2_maskV_-1.0=0.31608036, val_rnn_1_1step_CC_maskV_-1.0=0.63159239, learning_rate=0.001\n", + "Epoch 61/115 - loss=rnn_1_1step_loss=0.34193906, rnn_1_1step_R2_maskV_-1.0=0.64954448, rnn_1_1step_CC_maskV_-1.0=0.81151569, rnn_1_1step_MSE_maskV_-1.0=0.34193903, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5607546, val_rnn_1_1step_R2_maskV_-1.0=0.34978253, val_rnn_1_1step_CC_maskV_-1.0=0.65867847, learning_rate=0.001\n", + "Epoch 73/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.29884681, rnn_1_1step_R2_maskV_-1.0=0.69353175, rnn_1_1step_CC_maskV_-1.0=0.8376109, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53792745, val_rnn_1_1step_R2_maskV_-1.0=0.37594932, val_rnn_1_1step_CC_maskV_-1.0=0.67867911, learning_rate=0.001\n", + "Epoch 85/115 - loss=rnn_1_1step_loss=0.26165685, rnn_1_1step_R2_maskV_-1.0=0.73137558, rnn_1_1step_CC_maskV_-1.0=0.85952753, rnn_1_1step_MSE_maskV_-1.0=0.26165682, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51725036, val_rnn_1_1step_R2_maskV_-1.0=0.40005735, val_rnn_1_1step_CC_maskV_-1.0=0.69666106, learning_rate=0.001\n", + "Epoch 97/115 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.23348276, rnn_1_1step_R2_maskV_-1.0=0.75951838, rnn_1_1step_CC_maskV_-1.0=0.87578392, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53467625, val_rnn_1_1step_R2_maskV_-1.0=0.3792797, val_rnn_1_1step_CC_maskV_-1.0=0.69689798, learning_rate=0.001\n", + "Epoch 109/115 - loss=rnn_1_1step_loss=0.21409059, rnn_1_1step_R2_maskV_-1.0=0.779149, rnn_1_1step_CC_maskV_-1.0=0.88682765, rnn_1_1step_MSE_maskV_-1.0=0.21409057, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51848221, val_rnn_1_1step_R2_maskV_-1.0=0.39952812, val_rnn_1_1step_CC_maskV_-1.0=0.70241672, learning_rate=0.001\n", + "Epoch 115/115 - loss=rnn_1_1step_loss=0.20696181, rnn_1_1step_R2_maskV_-1.0=0.78615952, rnn_1_1step_CC_maskV_-1.0=0.891289, rnn_1_1step_MSE_maskV_-1.0=0.20696183, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52665859, val_rnn_1_1step_R2_maskV_-1.0=0.3885051, val_rnn_1_1step_CC_maskV_-1.0=0.70575941, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:03:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 13.43s\n", + "\u001b[32m2025-05-30 16:03:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.49330068)\n", + "\u001b[32m2025-05-30 16:03:28\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.21, R2_maskV_-1.0=0.79, CC_maskV_-1.0=0.89\n", + "\u001b[32m2025-05-30 16:03:28\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.445, R2_maskV_-1.0=0.495, CC_maskV_-1.0=0.741\n", + "\u001b[32m2025-05-30 16:03:28\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:03:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:04:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 141 (stopped at 156 epochs).\n", + "\u001b[32m2025-05-30 16:04:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/157 - loss=2.9560688, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.029708404, MSE_maskV_-1.0=2.950685, val_loss=1.1888843, val_CC_maskV_-1.0=0.07540521, val_MSE_maskV_-1.0=1.1860875, learning_rate=0.001\n", + "Epoch 17/157 - loss=0.88411742, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34156385, MSE_maskV_-1.0=0.88415426, val_loss=0.91077942, val_CC_maskV_-1.0=0.34428599, val_MSE_maskV_-1.0=0.90708339, learning_rate=0.001\n", + "Epoch 33/157 - loss=0.86667883, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36689797, MSE_maskV_-1.0=0.86648232, val_loss=0.88857055, val_CC_maskV_-1.0=0.37434414, val_MSE_maskV_-1.0=0.88526446, learning_rate=0.001\n", + "Epoch 49/157 - loss=0.85778397, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37883288, MSE_maskV_-1.0=0.85789269, val_loss=0.8831079, val_CC_maskV_-1.0=0.38172874, val_MSE_maskV_-1.0=0.87951338, learning_rate=0.001\n", + "Epoch 65/157 - loss=0.85238141, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38529724, MSE_maskV_-1.0=0.85178119, val_loss=0.87484586, val_CC_maskV_-1.0=0.39171451, val_MSE_maskV_-1.0=0.87176746, learning_rate=0.001\n", + "Epoch 81/157 - loss=0.84672821, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39326894, MSE_maskV_-1.0=0.84710288, val_loss=0.86777198, val_CC_maskV_-1.0=0.40026709, val_MSE_maskV_-1.0=0.86467206, learning_rate=0.001\n", + "Epoch 97/157 - loss=0.84279954, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39799652, MSE_maskV_-1.0=0.84335738, val_loss=0.86320931, val_CC_maskV_-1.0=0.40554824, val_MSE_maskV_-1.0=0.86042553, learning_rate=0.001\n", + "Epoch 113/157 - loss=0.83876127, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40220353, MSE_maskV_-1.0=0.84257197, val_loss=0.86215895, val_CC_maskV_-1.0=0.4067274, val_MSE_maskV_-1.0=0.85914749, learning_rate=0.001\n", + "Epoch 129/157 - loss=0.83586729, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40627599, MSE_maskV_-1.0=0.83600849, val_loss=0.85594422, val_CC_maskV_-1.0=0.41459936, val_MSE_maskV_-1.0=0.85289365, learning_rate=0.001\n", + "Epoch 145/157 - loss=0.83233136, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41042832, MSE_maskV_-1.0=0.83204919, val_loss=0.85450774, val_CC_maskV_-1.0=0.41644695, val_MSE_maskV_-1.0=0.85119706, learning_rate=0.001\n", + "Epoch 157/157 - loss=0.83004385, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41393292, MSE_maskV_-1.0=0.82979643, val_loss=0.85171247, val_CC_maskV_-1.0=0.41994154, val_MSE_maskV_-1.0=0.84845269, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:04:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 37.89s\n", + "\u001b[32m2025-05-30 16:04:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:04:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 141 (stopped at 156 epochs).\n", + "\u001b[32m2025-05-30 16:04:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/157 - loss=2.8757811, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=-0.0063396404, MSE_maskV_-1.0=2.8706863, val_loss=1.2226886, val_CC_maskV_-1.0=0.0049664741, val_MSE_maskV_-1.0=1.2186891, learning_rate=0.001\n", + "Epoch 17/157 - loss=0.8886801, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.33501351, MSE_maskV_-1.0=0.88872731, val_loss=0.91594094, val_CC_maskV_-1.0=0.33655885, val_MSE_maskV_-1.0=0.91260499, learning_rate=0.001\n", + "Epoch 33/157 - loss=0.86843979, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36460894, MSE_maskV_-1.0=0.86824822, val_loss=0.89122158, val_CC_maskV_-1.0=0.37026036, val_MSE_maskV_-1.0=0.8881892, learning_rate=0.001\n", + "Epoch 49/157 - loss=0.85869515, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37775046, MSE_maskV_-1.0=0.85876954, val_loss=0.88490468, val_CC_maskV_-1.0=0.37873915, val_MSE_maskV_-1.0=0.8814615, learning_rate=0.001\n", + "Epoch 65/157 - loss=0.85304052, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38447881, MSE_maskV_-1.0=0.85244614, val_loss=0.87626404, val_CC_maskV_-1.0=0.38920394, val_MSE_maskV_-1.0=0.87334621, learning_rate=0.001\n", + "Epoch 81/157 - loss=0.84731948, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39248675, MSE_maskV_-1.0=0.847682, val_loss=0.8688525, val_CC_maskV_-1.0=0.3982318, val_MSE_maskV_-1.0=0.8658582, learning_rate=0.001\n", + "Epoch 97/157 - loss=0.84336179, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39724332, MSE_maskV_-1.0=0.8439346, val_loss=0.86444688, val_CC_maskV_-1.0=0.40329885, val_MSE_maskV_-1.0=0.86174989, learning_rate=0.001\n", + "Epoch 113/157 - loss=0.83929706, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40154669, MSE_maskV_-1.0=0.84312052, val_loss=0.86328876, val_CC_maskV_-1.0=0.40473613, val_MSE_maskV_-1.0=0.86033171, learning_rate=0.001\n", + "Epoch 129/157 - loss=0.83638185, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40560859, MSE_maskV_-1.0=0.83652985, val_loss=0.85713339, val_CC_maskV_-1.0=0.41250759, val_MSE_maskV_-1.0=0.85412705, learning_rate=0.001\n", + "Epoch 145/157 - loss=0.83286899, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40972778, MSE_maskV_-1.0=0.83259326, val_loss=0.85569841, val_CC_maskV_-1.0=0.41444063, val_MSE_maskV_-1.0=0.85239959, learning_rate=0.001\n", + "Epoch 157/157 - loss=0.83057034, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41326991, MSE_maskV_-1.0=0.8303172, val_loss=0.8529495, val_CC_maskV_-1.0=0.41784108, val_MSE_maskV_-1.0=0.84970003, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:04:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 37.85s\n", + "\u001b[32m2025-05-30 16:04:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.85091454)\n", + "\u001b[32m2025-05-30 16:04:44\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 711us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:04:44\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.834, R2_maskV_-1.0=0.166, CC_maskV_-1.0=0.409\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 761us/step\n", + "51/51 [==============================] - 0s 692us/step\n", + "84/84 [==============================] - 0s 617us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:04:45\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_KCz1HL64U_ErSV16\" (9/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_KCz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:04:45\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_KCy1HL64U_ErSV16\" (10/16)\n", + "\u001b[32m2025-05-30 16:04:45\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:04:45\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:04:45\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:04:45\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:04:45\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:04:45\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:04:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:04:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 74 (stopped at 89 epochs).\n", + "\u001b[32m2025-05-30 16:04:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/90 - loss=rnn_1step_loss=1.0010403, rnn_1step_R2_maskV_-1.0=-0.012318078, rnn_1step_CC_maskV_-1.0=0.13070248, rnn_1step_MSE_maskV_-1.0=1.0010405, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91737038, val_rnn_1step_R2_maskV_-1.0=-0.059541449, val_rnn_1step_CC_maskV_-1.0=0.18246418, learning_rate=0.001\n", + "Epoch 10/90 - loss=rnn_1step_loss=0.8786853, rnn_1step_R2_maskV_-1.0=0.11168429, rnn_1step_CC_maskV_-1.0=0.39177197, rnn_1step_MSE_maskV_-1.0=0.87868524, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.81586784, val_rnn_1step_R2_maskV_-1.0=0.055679813, val_rnn_1step_CC_maskV_-1.0=0.37064964, learning_rate=0.001\n", + "Epoch 19/90 - loss=rnn_1step_loss=0.61105901, rnn_1step_R2_maskV_-1.0=0.37633485, rnn_1step_CC_maskV_-1.0=0.62381744, rnn_1step_MSE_maskV_-1.0=0.61105907, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.65802604, val_rnn_1step_R2_maskV_-1.0=0.23626572, val_rnn_1step_CC_maskV_-1.0=0.55302018, learning_rate=0.001\n", + "Epoch 28/90 - loss=rnn_1step_loss=0.47916028, rnn_1step_R2_maskV_-1.0=0.51062858, rnn_1step_CC_maskV_-1.0=0.72100639, rnn_1step_MSE_maskV_-1.0=0.47916025, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56933069, val_rnn_1step_R2_maskV_-1.0=0.33778507, val_rnn_1step_CC_maskV_-1.0=0.63148391, learning_rate=0.001\n", + "Epoch 37/90 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40840378, rnn_1step_R2_maskV_-1.0=0.5828082, rnn_1step_CC_maskV_-1.0=0.7687974, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5381816, val_rnn_1step_R2_maskV_-1.0=0.37458697, val_rnn_1step_CC_maskV_-1.0=0.65952826, learning_rate=0.001\n", + "Epoch 46/90 - loss=rnn_1step_loss=0.36976555, rnn_1step_R2_maskV_-1.0=0.62241817, rnn_1step_CC_maskV_-1.0=0.79363394, rnn_1step_MSE_maskV_-1.0=0.36976552, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52444786, val_rnn_1step_R2_maskV_-1.0=0.39114803, val_rnn_1step_CC_maskV_-1.0=0.67324966, learning_rate=0.001\n", + "Epoch 55/90 - loss=rnn_1step_loss=0.33612213, rnn_1step_R2_maskV_-1.0=0.6571995, rnn_1step_CC_maskV_-1.0=0.81467247, rnn_1step_MSE_maskV_-1.0=0.33612216, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50812769, val_rnn_1step_R2_maskV_-1.0=0.41046354, val_rnn_1step_CC_maskV_-1.0=0.68764663, learning_rate=0.001\n", + "Epoch 64/90 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29859841, rnn_1step_R2_maskV_-1.0=0.69571704, rnn_1step_CC_maskV_-1.0=0.83750731, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48960066, val_rnn_1step_R2_maskV_-1.0=0.43224499, val_rnn_1step_CC_maskV_-1.0=0.70654744, learning_rate=0.001\n", + "Epoch 73/90 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.26477882, rnn_1step_R2_maskV_-1.0=0.72973633, rnn_1step_CC_maskV_-1.0=0.85753489, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48159918, val_rnn_1step_R2_maskV_-1.0=0.4415701, val_rnn_1step_CC_maskV_-1.0=0.71986204, learning_rate=0.001\n", + "Epoch 82/90 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.24338292, rnn_1step_R2_maskV_-1.0=0.75115728, rnn_1step_CC_maskV_-1.0=0.86993176, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48440132, val_rnn_1step_R2_maskV_-1.0=0.43831617, val_rnn_1step_CC_maskV_-1.0=0.72342634, learning_rate=0.001\n", + "Epoch 90/90 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.23076469, rnn_1step_R2_maskV_-1.0=0.76384574, rnn_1step_CC_maskV_-1.0=0.87714815, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49008599, val_rnn_1step_R2_maskV_-1.0=0.4316963, val_rnn_1step_CC_maskV_-1.0=0.72351789, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:04:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.10s\n", + "\u001b[32m2025-05-30 16:04:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:05:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 73 (stopped at 88 epochs).\n", + "\u001b[32m2025-05-30 16:05:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/89 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0012728, rnn_1_1step_R2_maskV_-1.0=-0.012538418, rnn_1_1step_CC_maskV_-1.0=0.13939628, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91627496, val_rnn_1_1step_R2_maskV_-1.0=-0.058305666, val_rnn_1_1step_CC_maskV_-1.0=0.27927288, learning_rate=0.001\n", + "Epoch 10/89 - loss=rnn_1_1step_loss=0.85303718, rnn_1_1step_R2_maskV_-1.0=0.13754502, rnn_1_1step_CC_maskV_-1.0=0.4708522, rnn_1_1step_MSE_maskV_-1.0=0.85303724, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.77368337, val_rnn_1_1step_R2_maskV_-1.0=0.10341991, val_rnn_1_1step_CC_maskV_-1.0=0.4385823, learning_rate=0.001\n", + "Epoch 19/89 - loss=rnn_1_1step_loss=0.61077702, rnn_1_1step_R2_maskV_-1.0=0.37751836, rnn_1_1step_CC_maskV_-1.0=0.62491429, rnn_1_1step_MSE_maskV_-1.0=0.61077696, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62891489, val_rnn_1_1step_R2_maskV_-1.0=0.26970273, val_rnn_1_1step_CC_maskV_-1.0=0.57125372, learning_rate=0.001\n", + "Epoch 28/89 - loss=rnn_1_1step_loss=0.50285107, rnn_1_1step_R2_maskV_-1.0=0.48572376, rnn_1_1step_CC_maskV_-1.0=0.70467639, rnn_1_1step_MSE_maskV_-1.0=0.50285113, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59653592, val_rnn_1_1step_R2_maskV_-1.0=0.30791289, val_rnn_1_1step_CC_maskV_-1.0=0.61266935, learning_rate=0.001\n", + "Epoch 37/89 - loss=rnn_1_1step_loss=0.4357729, rnn_1_1step_R2_maskV_-1.0=0.55367076, rnn_1_1step_CC_maskV_-1.0=0.75104696, rnn_1_1step_MSE_maskV_-1.0=0.43577293, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56232923, val_rnn_1_1step_R2_maskV_-1.0=0.3468993, val_rnn_1_1step_CC_maskV_-1.0=0.64786333, learning_rate=0.001\n", + "Epoch 46/89 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38957223, rnn_1_1step_R2_maskV_-1.0=0.60100877, rnn_1_1step_CC_maskV_-1.0=0.78125703, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54106599, val_rnn_1_1step_R2_maskV_-1.0=0.3704792, val_rnn_1_1step_CC_maskV_-1.0=0.66715032, learning_rate=0.001\n", + "Epoch 55/89 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.35371414, rnn_1_1step_R2_maskV_-1.0=0.63806522, rnn_1_1step_CC_maskV_-1.0=0.80393171, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52510184, val_rnn_1_1step_R2_maskV_-1.0=0.3891148, val_rnn_1_1step_CC_maskV_-1.0=0.68068045, learning_rate=0.001\n", + "Epoch 64/89 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31122825, rnn_1_1step_R2_maskV_-1.0=0.68218035, rnn_1_1step_CC_maskV_-1.0=0.83003759, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50124049, val_rnn_1_1step_R2_maskV_-1.0=0.41773093, val_rnn_1_1step_CC_maskV_-1.0=0.69996458, learning_rate=0.001\n", + "Epoch 73/89 - loss=rnn_1_1step_loss=0.2662214, rnn_1_1step_R2_maskV_-1.0=0.72825009, rnn_1_1step_CC_maskV_-1.0=0.85683262, rnn_1_1step_MSE_maskV_-1.0=0.26622143, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47984448, val_rnn_1_1step_R2_maskV_-1.0=0.44367933, val_rnn_1_1step_CC_maskV_-1.0=0.71936327, learning_rate=0.001\n", + "Epoch 82/89 - loss=rnn_1_1step_loss=0.24341714, rnn_1_1step_R2_maskV_-1.0=0.75135237, rnn_1_1step_CC_maskV_-1.0=0.87006795, rnn_1_1step_MSE_maskV_-1.0=0.24341713, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48303452, val_rnn_1_1step_R2_maskV_-1.0=0.4398711, val_rnn_1_1step_CC_maskV_-1.0=0.721793, learning_rate=0.001\n", + "Epoch 89/89 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.23120153, rnn_1_1step_R2_maskV_-1.0=0.7637496, rnn_1_1step_CC_maskV_-1.0=0.87705314, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48440209, val_rnn_1_1step_R2_maskV_-1.0=0.43822667, val_rnn_1_1step_CC_maskV_-1.0=0.72337991, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:05:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 9.99s\n", + "\u001b[32m2025-05-30 16:05:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.47984448)\n", + "\u001b[32m2025-05-30 16:05:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.238, R2_maskV_-1.0=0.763, CC_maskV_-1.0=0.873\n", + "\u001b[32m2025-05-30 16:05:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.434, R2_maskV_-1.0=0.509, CC_maskV_-1.0=0.75\n", + "\u001b[32m2025-05-30 16:05:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:05:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:05:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 141 (stopped at 156 epochs).\n", + "\u001b[32m2025-05-30 16:05:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/157 - loss=1.0329628, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.14458683, MSE_maskV_-1.0=1.0331029, val_loss=0.97820079, val_CC_maskV_-1.0=0.22118196, val_MSE_maskV_-1.0=0.97618157, learning_rate=0.001\n", + "Epoch 17/157 - loss=0.82330835, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42328367, MSE_maskV_-1.0=0.82334536, val_loss=0.86349958, val_CC_maskV_-1.0=0.40548462, val_MSE_maskV_-1.0=0.86040521, learning_rate=0.001\n", + "Epoch 33/157 - loss=0.78545755, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46510381, MSE_maskV_-1.0=0.78527027, val_loss=0.83072364, val_CC_maskV_-1.0=0.44135565, val_MSE_maskV_-1.0=0.82854992, learning_rate=0.001\n", + "Epoch 49/157 - loss=0.76762491, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48376995, MSE_maskV_-1.0=0.76753336, val_loss=0.81889081, val_CC_maskV_-1.0=0.45362511, val_MSE_maskV_-1.0=0.81687146, learning_rate=0.001\n", + "Epoch 65/157 - loss=0.75665367, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49429125, MSE_maskV_-1.0=0.75616103, val_loss=0.81022924, val_CC_maskV_-1.0=0.46280694, val_MSE_maskV_-1.0=0.80829304, learning_rate=0.001\n", + "Epoch 81/157 - loss=0.74770606, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50342029, MSE_maskV_-1.0=0.74801552, val_loss=0.80111009, val_CC_maskV_-1.0=0.47274795, val_MSE_maskV_-1.0=0.79880404, learning_rate=0.001\n", + "Epoch 97/157 - loss=0.74157524, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50904804, MSE_maskV_-1.0=0.74198598, val_loss=0.79890651, val_CC_maskV_-1.0=0.47459018, val_MSE_maskV_-1.0=0.79669631, learning_rate=0.001\n", + "Epoch 113/157 - loss=0.73566711, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51410973, MSE_maskV_-1.0=0.73889333, val_loss=0.79627752, val_CC_maskV_-1.0=0.47750604, val_MSE_maskV_-1.0=0.7941159, learning_rate=0.001\n", + "Epoch 129/157 - loss=0.73158741, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51844156, MSE_maskV_-1.0=0.731677, val_loss=0.7882055, val_CC_maskV_-1.0=0.48543963, val_MSE_maskV_-1.0=0.78574425, learning_rate=0.001\n", + "Epoch 145/157 - loss=0.72769588, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52150154, MSE_maskV_-1.0=0.72737259, val_loss=0.78550583, val_CC_maskV_-1.0=0.48825532, val_MSE_maskV_-1.0=0.78307539, learning_rate=0.001\n", + "Epoch 157/157 - loss=0.72473609, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52455527, MSE_maskV_-1.0=0.72470862, val_loss=0.78457248, val_CC_maskV_-1.0=0.48995537, val_MSE_maskV_-1.0=0.78216022, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:05:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 40.10s\n", + "\u001b[32m2025-05-30 16:05:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:06:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 150 (stopped at 165 epochs).\n", + "\u001b[32m2025-05-30 16:06:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/166 - loss=1.0311892, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.14972813, MSE_maskV_-1.0=1.0313065, val_loss=0.97325182, val_CC_maskV_-1.0=0.23411757, val_MSE_maskV_-1.0=0.97136313, learning_rate=0.001\n", + "Epoch 18/166 - loss=0.82354397, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42327961, MSE_maskV_-1.0=0.82371724, val_loss=0.86499745, val_CC_maskV_-1.0=0.4011226, val_MSE_maskV_-1.0=0.8625223, learning_rate=0.001\n", + "Epoch 35/166 - loss=0.78645527, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46334308, MSE_maskV_-1.0=0.78598338, val_loss=0.83190125, val_CC_maskV_-1.0=0.43939278, val_MSE_maskV_-1.0=0.8299768, learning_rate=0.001\n", + "Epoch 52/166 - loss=0.76919961, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48120618, MSE_maskV_-1.0=0.76957029, val_loss=0.82000822, val_CC_maskV_-1.0=0.45201918, val_MSE_maskV_-1.0=0.81874448, learning_rate=0.001\n", + "Epoch 69/166 - loss=0.75729471, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49270293, MSE_maskV_-1.0=0.75761133, val_loss=0.80739653, val_CC_maskV_-1.0=0.46649891, val_MSE_maskV_-1.0=0.80507356, learning_rate=0.001\n", + "Epoch 86/166 - loss=0.74886853, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50111479, MSE_maskV_-1.0=0.75128084, val_loss=0.80579776, val_CC_maskV_-1.0=0.46848109, val_MSE_maskV_-1.0=0.80326718, learning_rate=0.001\n", + "Epoch 103/166 - loss=0.74236369, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50848311, MSE_maskV_-1.0=0.74231058, val_loss=0.79668427, val_CC_maskV_-1.0=0.47728494, val_MSE_maskV_-1.0=0.79430407, learning_rate=0.001\n", + "Epoch 120/166 - loss=0.73733568, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51334953, MSE_maskV_-1.0=0.73681539, val_loss=0.79325807, val_CC_maskV_-1.0=0.48039991, val_MSE_maskV_-1.0=0.79136974, learning_rate=0.001\n", + "Epoch 137/166 - loss=0.73333836, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5170086, MSE_maskV_-1.0=0.73317474, val_loss=0.79396266, val_CC_maskV_-1.0=0.47939801, val_MSE_maskV_-1.0=0.79163408, learning_rate=0.001\n", + "Epoch 154/166 - loss=0.72913146, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51989692, MSE_maskV_-1.0=0.72875792, val_loss=0.78749979, val_CC_maskV_-1.0=0.48703063, val_MSE_maskV_-1.0=0.78512162, learning_rate=0.001\n", + "Epoch 166/166 - loss=0.72685593, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52357209, MSE_maskV_-1.0=0.72739393, val_loss=0.78686386, val_CC_maskV_-1.0=0.48736176, val_MSE_maskV_-1.0=0.78441393, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:06:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 42.89s\n", + "\u001b[32m2025-05-30 16:06:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.78334469)\n", + "\u001b[32m2025-05-30 16:06:30\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 803us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:06:30\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.73, R2_maskV_-1.0=0.27, CC_maskV_-1.0=0.52\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 774us/step\n", + "51/51 [==============================] - 0s 766us/step\n", + "84/84 [==============================] - 0s 736us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:06:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_KCy1HL64U_ErSV16\" (10/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_KCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:06:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_CzCy1HL64U_ErSV16\" (11/16)\n", + "\u001b[32m2025-05-30 16:06:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_CzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:06:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:06:31\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:06:31\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:06:31\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:06:31\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:06:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:07:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 277 (stopped at 292 epochs).\n", + "\u001b[32m2025-05-30 16:07:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/293 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0022573, rnn_1step_R2_maskV_-1.0=-0.013555355, rnn_1step_CC_maskV_-1.0=0.028716905, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91764647, val_rnn_1step_R2_maskV_-1.0=-0.059854299, val_rnn_1step_CC_maskV_-1.0=0.24980269, learning_rate=0.001\n", + "Epoch 31/293 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.56062454, rnn_1step_R2_maskV_-1.0=0.42584193, rnn_1step_CC_maskV_-1.0=0.66302055, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.61861128, val_rnn_1step_R2_maskV_-1.0=0.2837466, val_rnn_1step_CC_maskV_-1.0=0.58495891, learning_rate=0.001\n", + "Epoch 61/293 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.43356565, rnn_1step_R2_maskV_-1.0=0.55437255, rnn_1step_CC_maskV_-1.0=0.752859, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57152534, val_rnn_1step_R2_maskV_-1.0=0.33528864, val_rnn_1step_CC_maskV_-1.0=0.64402133, learning_rate=0.001\n", + "Epoch 91/293 - loss=rnn_1step_loss=0.40600109, rnn_1step_R2_maskV_-1.0=0.58194906, rnn_1step_CC_maskV_-1.0=0.77084494, rnn_1step_MSE_maskV_-1.0=0.40600106, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55430573, val_rnn_1step_R2_maskV_-1.0=0.35563868, val_rnn_1step_CC_maskV_-1.0=0.65601319, learning_rate=0.001\n", + "Epoch 121/293 - loss=rnn_1step_loss=0.38562489, rnn_1step_R2_maskV_-1.0=0.60268593, rnn_1step_CC_maskV_-1.0=0.78379703, rnn_1step_MSE_maskV_-1.0=0.38562486, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53914618, val_rnn_1step_R2_maskV_-1.0=0.37397, val_rnn_1step_CC_maskV_-1.0=0.66633326, learning_rate=0.001\n", + "Epoch 151/293 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.36281058, rnn_1step_R2_maskV_-1.0=0.62625003, rnn_1step_CC_maskV_-1.0=0.79806823, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52595192, val_rnn_1step_R2_maskV_-1.0=0.39006796, val_rnn_1step_CC_maskV_-1.0=0.678406, learning_rate=0.001\n", + "Epoch 181/293 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34014949, rnn_1step_R2_maskV_-1.0=0.6493277, rnn_1step_CC_maskV_-1.0=0.81203938, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51508683, val_rnn_1step_R2_maskV_-1.0=0.40289891, val_rnn_1step_CC_maskV_-1.0=0.69342214, learning_rate=0.001\n", + "Epoch 211/293 - loss=rnn_1step_loss=0.32727817, rnn_1step_R2_maskV_-1.0=0.6619547, rnn_1step_CC_maskV_-1.0=0.81988484, rnn_1step_MSE_maskV_-1.0=0.32727814, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51276332, val_rnn_1step_R2_maskV_-1.0=0.40532288, val_rnn_1step_CC_maskV_-1.0=0.69994926, learning_rate=0.001\n", + "Epoch 241/293 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31968537, rnn_1step_R2_maskV_-1.0=0.66939443, rnn_1step_CC_maskV_-1.0=0.82452357, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5097754, val_rnn_1step_R2_maskV_-1.0=0.4088769, val_rnn_1step_CC_maskV_-1.0=0.7030077, learning_rate=0.001\n", + "Epoch 271/293 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31403717, rnn_1step_R2_maskV_-1.0=0.67529196, rnn_1step_CC_maskV_-1.0=0.8279745, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51274008, val_rnn_1step_R2_maskV_-1.0=0.40536338, val_rnn_1step_CC_maskV_-1.0=0.70279837, learning_rate=0.001\n", + "Epoch 293/293 - loss=rnn_1step_loss=0.31070539, rnn_1step_R2_maskV_-1.0=0.67863047, rnn_1step_CC_maskV_-1.0=0.82995868, rnn_1step_MSE_maskV_-1.0=0.31070536, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50883812, val_rnn_1step_R2_maskV_-1.0=0.40994453, val_rnn_1step_CC_maskV_-1.0=0.70439947, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:07:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 28.50s\n", + "\u001b[32m2025-05-30 16:07:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:07:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 163 (stopped at 178 epochs).\n", + "\u001b[32m2025-05-30 16:07:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/179 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0014076, rnn_1_1step_R2_maskV_-1.0=-0.012726903, rnn_1_1step_CC_maskV_-1.0=0.10157356, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91569138, val_rnn_1_1step_R2_maskV_-1.0=-0.057520941, val_rnn_1_1step_CC_maskV_-1.0=0.27452007, learning_rate=0.001\n", + "Epoch 19/179 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.6836803, rnn_1_1step_R2_maskV_-1.0=0.30219334, rnn_1_1step_CC_maskV_-1.0=0.56292856, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.66989326, val_rnn_1_1step_R2_maskV_-1.0=0.22230996, val_rnn_1_1step_CC_maskV_-1.0=0.52538824, learning_rate=0.001\n", + "Epoch 37/179 - loss=rnn_1_1step_loss=0.53902239, rnn_1_1step_R2_maskV_-1.0=0.4468008, rnn_1_1step_CC_maskV_-1.0=0.6787765, rnn_1_1step_MSE_maskV_-1.0=0.53902245, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60648847, val_rnn_1_1step_R2_maskV_-1.0=0.2960583, val_rnn_1_1step_CC_maskV_-1.0=0.59840709, learning_rate=0.001\n", + "Epoch 55/179 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.47297612, rnn_1_1step_R2_maskV_-1.0=0.51376665, rnn_1_1step_CC_maskV_-1.0=0.72558677, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58158082, val_rnn_1_1step_R2_maskV_-1.0=0.32505137, val_rnn_1_1step_CC_maskV_-1.0=0.62923795, learning_rate=0.001\n", + "Epoch 73/179 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42520177, rnn_1_1step_R2_maskV_-1.0=0.56240237, rnn_1_1step_CC_maskV_-1.0=0.75787657, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5782401, val_rnn_1_1step_R2_maskV_-1.0=0.32734895, val_rnn_1_1step_CC_maskV_-1.0=0.64224803, learning_rate=0.001\n", + "Epoch 91/179 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40584683, rnn_1_1step_R2_maskV_-1.0=0.5821386, rnn_1_1step_CC_maskV_-1.0=0.77064174, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56548333, val_rnn_1_1step_R2_maskV_-1.0=0.3420071, val_rnn_1_1step_CC_maskV_-1.0=0.65164357, learning_rate=0.001\n", + "Epoch 109/179 - loss=rnn_1_1step_loss=0.38874137, rnn_1_1step_R2_maskV_-1.0=0.59969461, rnn_1_1step_CC_maskV_-1.0=0.78162295, rnn_1_1step_MSE_maskV_-1.0=0.3887414, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55160362, val_rnn_1_1step_R2_maskV_-1.0=0.35859919, val_rnn_1_1step_CC_maskV_-1.0=0.66169775, learning_rate=0.001\n", + "Epoch 127/179 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36886024, rnn_1_1step_R2_maskV_-1.0=0.62026072, rnn_1_1step_CC_maskV_-1.0=0.79416037, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5378775, val_rnn_1_1step_R2_maskV_-1.0=0.37535426, val_rnn_1_1step_CC_maskV_-1.0=0.67390049, learning_rate=0.001\n", + "Epoch 145/179 - loss=rnn_1_1step_loss=0.35100356, rnn_1_1step_R2_maskV_-1.0=0.63833797, rnn_1_1step_CC_maskV_-1.0=0.80530733, rnn_1_1step_MSE_maskV_-1.0=0.35100359, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5249781, val_rnn_1_1step_R2_maskV_-1.0=0.39067337, val_rnn_1_1step_CC_maskV_-1.0=0.68690479, learning_rate=0.001\n", + "Epoch 163/179 - loss=rnn_1_1step_loss=0.34128794, rnn_1_1step_R2_maskV_-1.0=0.6479497, rnn_1_1step_CC_maskV_-1.0=0.8113876, rnn_1_1step_MSE_maskV_-1.0=0.34128791, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52130216, val_rnn_1_1step_R2_maskV_-1.0=0.39495575, val_rnn_1_1step_CC_maskV_-1.0=0.69237494, learning_rate=0.001\n", + "Epoch 179/179 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.335843, rnn_1_1step_R2_maskV_-1.0=0.65339243, rnn_1_1step_CC_maskV_-1.0=0.81476092, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52156687, val_rnn_1_1step_R2_maskV_-1.0=0.39457455, val_rnn_1_1step_CC_maskV_-1.0=0.6939435, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:07:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 18.36s\n", + "\u001b[32m2025-05-30 16:07:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.50779456)\n", + "\u001b[32m2025-05-30 16:07:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.284, R2_maskV_-1.0=0.716, CC_maskV_-1.0=0.847\n", + "\u001b[32m2025-05-30 16:07:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.474, R2_maskV_-1.0=0.463, CC_maskV_-1.0=0.728\n", + "\u001b[32m2025-05-30 16:07:20\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:07:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:07:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 72 (stopped at 87 epochs).\n", + "\u001b[32m2025-05-30 16:07:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/88 - loss=3.2498617, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.045068204, MSE_maskV_-1.0=3.2428985, val_loss=1.2244037, val_CC_maskV_-1.0=0.10936737, val_MSE_maskV_-1.0=1.2210827, learning_rate=0.001\n", + "Epoch 10/88 - loss=0.80305827, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44367024, MSE_maskV_-1.0=0.80354011, val_loss=0.83660692, val_CC_maskV_-1.0=0.43088138, val_MSE_maskV_-1.0=0.83312547, learning_rate=0.001\n", + "Epoch 19/88 - loss=0.73515069, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51427132, MSE_maskV_-1.0=0.73460466, val_loss=0.76803678, val_CC_maskV_-1.0=0.50065994, val_MSE_maskV_-1.0=0.76455045, learning_rate=0.001\n", + "Epoch 28/88 - loss=0.69217718, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55447865, MSE_maskV_-1.0=0.69270343, val_loss=0.72222257, val_CC_maskV_-1.0=0.54257703, val_MSE_maskV_-1.0=0.71884096, learning_rate=0.001\n", + "Epoch 37/88 - loss=0.66592246, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57739449, MSE_maskV_-1.0=0.66583443, val_loss=0.69609374, val_CC_maskV_-1.0=0.5643096, val_MSE_maskV_-1.0=0.69263381, learning_rate=0.001\n", + "Epoch 46/88 - loss=0.6505987, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59049773, MSE_maskV_-1.0=0.65124547, val_loss=0.6882754, val_CC_maskV_-1.0=0.57222712, val_MSE_maskV_-1.0=0.68442613, learning_rate=0.001\n", + "Epoch 55/88 - loss=0.64195722, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59712738, MSE_maskV_-1.0=0.64176309, val_loss=0.68255168, val_CC_maskV_-1.0=0.57641578, val_MSE_maskV_-1.0=0.67862403, learning_rate=0.001\n", + "Epoch 64/88 - loss=0.63609815, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60245723, MSE_maskV_-1.0=0.63562673, val_loss=0.67917013, val_CC_maskV_-1.0=0.57968342, val_MSE_maskV_-1.0=0.67497605, learning_rate=0.001\n", + "Epoch 73/88 - loss=0.63058269, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60625386, MSE_maskV_-1.0=0.6309135, val_loss=0.68412036, val_CC_maskV_-1.0=0.57674575, val_MSE_maskV_-1.0=0.67992657, learning_rate=0.001\n", + "Epoch 82/88 - loss=0.62757117, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60841089, MSE_maskV_-1.0=0.62780964, val_loss=0.67411733, val_CC_maskV_-1.0=0.5843882, val_MSE_maskV_-1.0=0.67009884, learning_rate=0.001\n", + "Epoch 88/88 - loss=0.62565178, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60984421, MSE_maskV_-1.0=0.62579834, val_loss=0.67535007, val_CC_maskV_-1.0=0.58379018, val_MSE_maskV_-1.0=0.67139381, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:07:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 23.16s\n", + "\u001b[32m2025-05-30 16:07:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:08:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 75 (stopped at 90 epochs).\n", + "\u001b[32m2025-05-30 16:08:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/91 - loss=2.8372927, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.087387457, MSE_maskV_-1.0=2.8321648, val_loss=1.1577739, val_CC_maskV_-1.0=0.14368874, val_MSE_maskV_-1.0=1.1493509, learning_rate=0.001\n", + "Epoch 11/91 - loss=0.78391933, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46401575, MSE_maskV_-1.0=0.78350109, val_loss=0.81430447, val_CC_maskV_-1.0=0.45638847, val_MSE_maskV_-1.0=0.80983412, learning_rate=0.001\n", + "Epoch 21/91 - loss=0.71715266, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53039813, MSE_maskV_-1.0=0.7172302, val_loss=0.74433845, val_CC_maskV_-1.0=0.52383596, val_MSE_maskV_-1.0=0.74027079, learning_rate=0.001\n", + "Epoch 31/91 - loss=0.67730743, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56713182, MSE_maskV_-1.0=0.67739487, val_loss=0.70927876, val_CC_maskV_-1.0=0.55474603, val_MSE_maskV_-1.0=0.70518923, learning_rate=0.001\n", + "Epoch 41/91 - loss=0.65610355, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58506191, MSE_maskV_-1.0=0.65965807, val_loss=0.6961686, val_CC_maskV_-1.0=0.56506234, val_MSE_maskV_-1.0=0.69226372, learning_rate=0.001\n", + "Epoch 51/91 - loss=0.64517963, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59447551, MSE_maskV_-1.0=0.64508671, val_loss=0.68212122, val_CC_maskV_-1.0=0.57767355, val_MSE_maskV_-1.0=0.677926, learning_rate=0.001\n", + "Epoch 61/91 - loss=0.63770169, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60135198, MSE_maskV_-1.0=0.63824958, val_loss=0.68292725, val_CC_maskV_-1.0=0.57697815, val_MSE_maskV_-1.0=0.67870122, learning_rate=0.001\n", + "Epoch 71/91 - loss=0.63261008, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60459715, MSE_maskV_-1.0=0.63290399, val_loss=0.67921805, val_CC_maskV_-1.0=0.57829386, val_MSE_maskV_-1.0=0.67518079, learning_rate=0.001\n", + "Epoch 81/91 - loss=0.6278981, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60892999, MSE_maskV_-1.0=0.6279707, val_loss=0.67050707, val_CC_maskV_-1.0=0.58585817, val_MSE_maskV_-1.0=0.66643906, learning_rate=0.001\n", + "Epoch 91/91 - loss=0.62466669, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61126012, MSE_maskV_-1.0=0.62472111, val_loss=0.67434037, val_CC_maskV_-1.0=0.58353758, val_MSE_maskV_-1.0=0.66985738, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:08:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 23.92s\n", + "\u001b[32m2025-05-30 16:08:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.67011189)\n", + "\u001b[32m2025-05-30 16:08:07\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 768us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:08:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.626, R2_maskV_-1.0=0.375, CC_maskV_-1.0=0.612\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 756us/step\n", + "51/51 [==============================] - 0s 763us/step\n", + "84/84 [==============================] - 0s 739us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:08:08\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_CzCy1HL64U_ErSV16\" (11/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_CzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:08:08\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_uAKCz1HL64U_ErSV16\" (12/16)\n", + "\u001b[32m2025-05-30 16:08:08\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:08:08\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:08:08\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:08:08\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:08:08\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:08:08\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:08:08\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:08:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 105 (stopped at 120 epochs).\n", + "\u001b[32m2025-05-30 16:08:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/121 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0022848, rnn_1step_R2_maskV_-1.0=-0.013613638, rnn_1step_CC_maskV_-1.0=0.060746014, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91784286, val_rnn_1step_R2_maskV_-1.0=-0.060055867, val_rnn_1step_CC_maskV_-1.0=0.30966884, learning_rate=0.001\n", + "Epoch 14/121 - loss=rnn_1step_loss=0.75721258, rnn_1step_R2_maskV_-1.0=0.22927129, rnn_1step_CC_maskV_-1.0=0.4989278, rnn_1step_MSE_maskV_-1.0=0.75721252, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.70784026, val_rnn_1step_R2_maskV_-1.0=0.17754249, val_rnn_1step_CC_maskV_-1.0=0.47026062, learning_rate=0.001\n", + "Epoch 27/121 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.58329773, rnn_1step_R2_maskV_-1.0=0.40166795, rnn_1step_CC_maskV_-1.0=0.64653379, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.65615481, val_rnn_1step_R2_maskV_-1.0=0.23760349, val_rnn_1step_CC_maskV_-1.0=0.54774839, learning_rate=0.001\n", + "Epoch 40/121 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4714202, rnn_1step_R2_maskV_-1.0=0.5140276, rnn_1step_CC_maskV_-1.0=0.72700214, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60317838, val_rnn_1step_R2_maskV_-1.0=0.30060247, val_rnn_1step_CC_maskV_-1.0=0.60923517, learning_rate=0.001\n", + "Epoch 53/121 - loss=rnn_1step_loss=0.3862839, rnn_1step_R2_maskV_-1.0=0.60021174, rnn_1step_CC_maskV_-1.0=0.78309131, rnn_1step_MSE_maskV_-1.0=0.38628393, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58286518, val_rnn_1step_R2_maskV_-1.0=0.32548088, val_rnn_1step_CC_maskV_-1.0=0.63600826, learning_rate=0.001\n", + "Epoch 66/121 - loss=rnn_1step_loss=0.33907953, rnn_1step_R2_maskV_-1.0=0.64869934, rnn_1step_CC_maskV_-1.0=0.81288725, rnn_1step_MSE_maskV_-1.0=0.3390795, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55825472, val_rnn_1step_R2_maskV_-1.0=0.35440922, val_rnn_1step_CC_maskV_-1.0=0.65515345, learning_rate=0.001\n", + "Epoch 79/121 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29905736, rnn_1step_R2_maskV_-1.0=0.69005245, rnn_1step_CC_maskV_-1.0=0.83777517, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56815559, val_rnn_1step_R2_maskV_-1.0=0.34230703, val_rnn_1step_CC_maskV_-1.0=0.66104382, learning_rate=0.001\n", + "Epoch 92/121 - loss=rnn_1step_loss=0.26514801, rnn_1step_R2_maskV_-1.0=0.7258352, rnn_1step_CC_maskV_-1.0=0.85820043, rnn_1step_MSE_maskV_-1.0=0.26514804, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53664511, val_rnn_1step_R2_maskV_-1.0=0.37875676, val_rnn_1step_CC_maskV_-1.0=0.67884886, learning_rate=0.001\n", + "Epoch 105/121 - loss=rnn_1step_loss=0.24061418, rnn_1step_R2_maskV_-1.0=0.75102693, rnn_1step_CC_maskV_-1.0=0.87212014, rnn_1step_MSE_maskV_-1.0=0.24061415, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53028059, val_rnn_1step_R2_maskV_-1.0=0.3859587, val_rnn_1step_CC_maskV_-1.0=0.68318045, learning_rate=0.001\n", + "Epoch 118/121 - loss=rnn_1step_loss=0.23304021, rnn_1step_R2_maskV_-1.0=0.75927138, rnn_1step_CC_maskV_-1.0=0.87728906, rnn_1step_MSE_maskV_-1.0=0.2330402, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53113073, val_rnn_1step_R2_maskV_-1.0=0.38479388, val_rnn_1step_CC_maskV_-1.0=0.68474799, learning_rate=0.001\n", + "Epoch 121/121 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.22198814, rnn_1step_R2_maskV_-1.0=0.77043819, rnn_1step_CC_maskV_-1.0=0.88327062, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53675199, val_rnn_1step_R2_maskV_-1.0=0.37845141, val_rnn_1step_CC_maskV_-1.0=0.6831013, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:08:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.78s\n", + "\u001b[32m2025-05-30 16:08:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:08:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 39 (stopped at 54 epochs).\n", + "\u001b[32m2025-05-30 16:08:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/55 - loss=rnn_1_1step_loss=1.0023299, rnn_1_1step_R2_maskV_-1.0=-0.013655499, rnn_1_1step_CC_maskV_-1.0=0.036138408, rnn_1_1step_MSE_maskV_-1.0=1.0023301, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91811115, val_rnn_1_1step_R2_maskV_-1.0=-0.060366467, val_rnn_1_1step_CC_maskV_-1.0=0.31114715, learning_rate=0.001\n", + "Epoch 7/55 - loss=rnn_1_1step_loss=0.97624224, rnn_1_1step_R2_maskV_-1.0=0.012897804, rnn_1_1step_CC_maskV_-1.0=0.35743076, rnn_1_1step_MSE_maskV_-1.0=0.97624218, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.88777465, val_rnn_1_1step_R2_maskV_-1.0=-0.026349828, val_rnn_1_1step_CC_maskV_-1.0=0.3278451, learning_rate=0.001\n", + "Epoch 13/55 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.83760637, rnn_1_1step_R2_maskV_-1.0=0.14838237, rnn_1_1step_CC_maskV_-1.0=0.40430564, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.77864456, val_rnn_1_1step_R2_maskV_-1.0=0.09565939, val_rnn_1_1step_CC_maskV_-1.0=0.39512968, learning_rate=0.001\n", + "Epoch 19/55 - loss=rnn_1_1step_loss=0.72405213, rnn_1_1step_R2_maskV_-1.0=0.26202399, rnn_1_1step_CC_maskV_-1.0=0.52574348, rnn_1_1step_MSE_maskV_-1.0=0.72405219, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.72420925, val_rnn_1_1step_R2_maskV_-1.0=0.15746348, val_rnn_1_1step_CC_maskV_-1.0=0.46831924, learning_rate=0.001\n", + "Epoch 25/55 - loss=rnn_1_1step_loss=0.59705824, rnn_1_1step_R2_maskV_-1.0=0.3894729, rnn_1_1step_CC_maskV_-1.0=0.63438553, rnn_1_1step_MSE_maskV_-1.0=0.5970583, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65878791, val_rnn_1_1step_R2_maskV_-1.0=0.23559728, val_rnn_1_1step_CC_maskV_-1.0=0.54956448, learning_rate=0.001\n", + "Epoch 31/55 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.52180535, rnn_1_1step_R2_maskV_-1.0=0.46538082, rnn_1_1step_CC_maskV_-1.0=0.69093513, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64276695, val_rnn_1_1step_R2_maskV_-1.0=0.2533614, val_rnn_1_1step_CC_maskV_-1.0=0.58165669, learning_rate=0.001\n", + "Epoch 37/55 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.47542763, rnn_1_1step_R2_maskV_-1.0=0.51246518, rnn_1_1step_CC_maskV_-1.0=0.72407907, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61433262, val_rnn_1_1step_R2_maskV_-1.0=0.28533524, val_rnn_1_1step_CC_maskV_-1.0=0.60872418, learning_rate=0.001\n", + "Epoch 43/55 - loss=rnn_1_1step_loss=0.45301977, rnn_1_1step_R2_maskV_-1.0=0.53421253, rnn_1_1step_CC_maskV_-1.0=0.74038422, rnn_1_1step_MSE_maskV_-1.0=0.4530198, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5764783, val_rnn_1_1step_R2_maskV_-1.0=0.32928416, val_rnn_1_1step_CC_maskV_-1.0=0.62820619, learning_rate=0.001\n", + "Epoch 49/55 - loss=rnn_1_1step_loss=0.43278956, rnn_1_1step_R2_maskV_-1.0=0.5557431, rnn_1_1step_CC_maskV_-1.0=0.75312436, rnn_1_1step_MSE_maskV_-1.0=0.43278953, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5883252, val_rnn_1_1step_R2_maskV_-1.0=0.31552714, val_rnn_1_1step_CC_maskV_-1.0=0.62805814, learning_rate=0.001\n", + "Epoch 55/55 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41116035, rnn_1_1step_R2_maskV_-1.0=0.57744974, rnn_1_1step_CC_maskV_-1.0=0.76761973, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57995635, val_rnn_1_1step_R2_maskV_-1.0=0.32506788, val_rnn_1_1step_CC_maskV_-1.0=0.63509864, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:08:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 8.19s\n", + "\u001b[32m2025-05-30 16:08:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.53028059)\n", + "\u001b[32m2025-05-30 16:08:33\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.223, R2_maskV_-1.0=0.777, CC_maskV_-1.0=0.882\n", + "\u001b[32m2025-05-30 16:08:33\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.477, R2_maskV_-1.0=0.459, CC_maskV_-1.0=0.721\n", + "\u001b[32m2025-05-30 16:08:33\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:08:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:09:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 313 (stopped at 328 epochs).\n", + "\u001b[32m2025-05-30 16:09:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/329 - loss=2.130456, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=-0.00021969179, MSE_maskV_-1.0=2.1273751, val_loss=1.1131665, val_CC_maskV_-1.0=0.081521004, val_MSE_maskV_-1.0=1.1122242, learning_rate=0.001\n", + "Epoch 34/329 - loss=0.88123006, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34918752, MSE_maskV_-1.0=0.88056201, val_loss=0.91471118, val_CC_maskV_-1.0=0.33810684, val_MSE_maskV_-1.0=0.91110814, learning_rate=0.001\n", + "Epoch 67/329 - loss=0.86077076, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37658042, MSE_maskV_-1.0=0.86044061, val_loss=0.89774132, val_CC_maskV_-1.0=0.36110261, val_MSE_maskV_-1.0=0.89393783, learning_rate=0.001\n", + "Epoch 100/329 - loss=0.85017443, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38887993, MSE_maskV_-1.0=0.85034198, val_loss=0.8869096, val_CC_maskV_-1.0=0.3748619, val_MSE_maskV_-1.0=0.88355702, learning_rate=0.001\n", + "Epoch 133/329 - loss=0.84296477, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39832252, MSE_maskV_-1.0=0.8427158, val_loss=0.87916189, val_CC_maskV_-1.0=0.38405782, val_MSE_maskV_-1.0=0.87578171, learning_rate=0.001\n", + "Epoch 166/329 - loss=0.83744264, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40594569, MSE_maskV_-1.0=0.83775991, val_loss=0.87146592, val_CC_maskV_-1.0=0.39315835, val_MSE_maskV_-1.0=0.86843497, learning_rate=0.001\n", + "Epoch 199/329 - loss=0.83315539, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41027129, MSE_maskV_-1.0=0.83303589, val_loss=0.87278509, val_CC_maskV_-1.0=0.39109585, val_MSE_maskV_-1.0=0.86952376, learning_rate=0.001\n", + "Epoch 232/329 - loss=0.82965475, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41432452, MSE_maskV_-1.0=0.82967567, val_loss=0.8638134, val_CC_maskV_-1.0=0.40086198, val_MSE_maskV_-1.0=0.86091948, learning_rate=0.001\n", + "Epoch 265/329 - loss=0.82728767, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4170396, MSE_maskV_-1.0=0.82730037, val_loss=0.86258167, val_CC_maskV_-1.0=0.40237936, val_MSE_maskV_-1.0=0.8595928, learning_rate=0.001\n", + "Epoch 298/329 - loss=0.82452685, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42060119, MSE_maskV_-1.0=0.82391876, val_loss=0.85833234, val_CC_maskV_-1.0=0.4071362, val_MSE_maskV_-1.0=0.85532516, learning_rate=0.001\n", + "Epoch 329/329 - loss=0.82222515, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42283452, MSE_maskV_-1.0=0.82155019, val_loss=0.86026347, val_CC_maskV_-1.0=0.40398359, val_MSE_maskV_-1.0=0.85723722, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:09:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 77.82s\n", + "\u001b[32m2025-05-30 16:09:51\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:10:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 172 (stopped at 187 epochs).\n", + "\u001b[32m2025-05-30 16:10:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/188 - loss=2.0448828, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.03688769, MSE_maskV_-1.0=2.0423272, val_loss=1.1021172, val_CC_maskV_-1.0=0.10188151, val_MSE_maskV_-1.0=1.1009001, learning_rate=0.001\n", + "Epoch 20/188 - loss=0.90187168, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.31698716, MSE_maskV_-1.0=0.90178919, val_loss=0.93192041, val_CC_maskV_-1.0=0.31212544, val_MSE_maskV_-1.0=0.92743129, learning_rate=0.001\n", + "Epoch 39/188 - loss=0.87794977, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35329476, MSE_maskV_-1.0=0.87794417, val_loss=0.91220534, val_CC_maskV_-1.0=0.33924195, val_MSE_maskV_-1.0=0.90853453, learning_rate=0.001\n", + "Epoch 58/188 - loss=0.86588198, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36912411, MSE_maskV_-1.0=0.86578184, val_loss=0.90292865, val_CC_maskV_-1.0=0.35299495, val_MSE_maskV_-1.0=0.89924192, learning_rate=0.001\n", + "Epoch 77/188 - loss=0.85855669, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37861964, MSE_maskV_-1.0=0.85767466, val_loss=0.89335197, val_CC_maskV_-1.0=0.36585, val_MSE_maskV_-1.0=0.88945949, learning_rate=0.001\n", + "Epoch 96/188 - loss=0.85241932, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38594347, MSE_maskV_-1.0=0.85245836, val_loss=0.89006495, val_CC_maskV_-1.0=0.36931711, val_MSE_maskV_-1.0=0.8867892, learning_rate=0.001\n", + "Epoch 115/188 - loss=0.84779662, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3924078, MSE_maskV_-1.0=0.8476457, val_loss=0.8840515, val_CC_maskV_-1.0=0.37778634, val_MSE_maskV_-1.0=0.88067448, learning_rate=0.001\n", + "Epoch 134/188 - loss=0.84393948, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39750156, MSE_maskV_-1.0=0.84531969, val_loss=0.8802675, val_CC_maskV_-1.0=0.38323075, val_MSE_maskV_-1.0=0.87648016, learning_rate=0.001\n", + "Epoch 153/188 - loss=0.84043956, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40150049, MSE_maskV_-1.0=0.84109575, val_loss=0.87709874, val_CC_maskV_-1.0=0.38563535, val_MSE_maskV_-1.0=0.8738144, learning_rate=0.001\n", + "Epoch 172/188 - loss=0.83741629, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40507698, MSE_maskV_-1.0=0.83860981, val_loss=0.87130392, val_CC_maskV_-1.0=0.39198807, val_MSE_maskV_-1.0=0.86798245, learning_rate=0.001\n", + "Epoch 188/188 - loss=0.83548701, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40720618, MSE_maskV_-1.0=0.83435428, val_loss=0.87150937, val_CC_maskV_-1.0=0.39257994, val_MSE_maskV_-1.0=0.86819273, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:10:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 44.49s\n", + "\u001b[32m2025-05-30 16:10:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.85638821)\n", + "\u001b[32m2025-05-30 16:10:35\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 723us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:10:35\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.822, R2_maskV_-1.0=0.178, CC_maskV_-1.0=0.423\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 728us/step\n", + "51/51 [==============================] - 0s 747us/step\n", + "84/84 [==============================] - 0s 706us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:10:36\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_uAKCz1HL64U_ErSV16\" (12/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_uAKCz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:10:36\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_uAKCy1HL64U_ErSV16\" (13/16)\n", + "\u001b[32m2025-05-30 16:10:36\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:10:36\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:10:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:10:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:10:36\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:10:36\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:10:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:10:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 89 (stopped at 104 epochs).\n", + "\u001b[32m2025-05-30 16:10:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/105 - loss=rnn_1step_loss=1.0014384, rnn_1step_R2_maskV_-1.0=-0.012763832, rnn_1step_CC_maskV_-1.0=0.12692469, rnn_1step_MSE_maskV_-1.0=1.0014383, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91525251, val_rnn_1step_R2_maskV_-1.0=-0.057040691, val_rnn_1step_CC_maskV_-1.0=0.29209054, learning_rate=0.001\n", + "Epoch 12/105 - loss=rnn_1step_loss=0.80326349, rnn_1step_R2_maskV_-1.0=0.18174447, rnn_1step_CC_maskV_-1.0=0.45071775, rnn_1step_MSE_maskV_-1.0=0.80326343, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.72773284, val_rnn_1step_R2_maskV_-1.0=0.15405704, val_rnn_1step_CC_maskV_-1.0=0.44773233, learning_rate=0.001\n", + "Epoch 23/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.58977282, rnn_1step_R2_maskV_-1.0=0.39713058, rnn_1step_CC_maskV_-1.0=0.64132202, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.65648586, val_rnn_1step_R2_maskV_-1.0=0.23701134, val_rnn_1step_CC_maskV_-1.0=0.54208136, learning_rate=0.001\n", + "Epoch 34/105 - loss=rnn_1step_loss=0.47607923, rnn_1step_R2_maskV_-1.0=0.51041716, rnn_1step_CC_maskV_-1.0=0.72344351, rnn_1step_MSE_maskV_-1.0=0.4760792, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.60371733, val_rnn_1step_R2_maskV_-1.0=0.29918966, val_rnn_1step_CC_maskV_-1.0=0.60125166, learning_rate=0.001\n", + "Epoch 45/105 - loss=rnn_1step_loss=0.39068714, rnn_1step_R2_maskV_-1.0=0.59682512, rnn_1step_CC_maskV_-1.0=0.78048313, rnn_1step_MSE_maskV_-1.0=0.39068717, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5666731, val_rnn_1step_R2_maskV_-1.0=0.34109768, val_rnn_1step_CC_maskV_-1.0=0.64417863, learning_rate=0.001\n", + "Epoch 56/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3334558, rnn_1step_R2_maskV_-1.0=0.65587163, rnn_1step_CC_maskV_-1.0=0.81686497, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54421794, val_rnn_1step_R2_maskV_-1.0=0.36706215, val_rnn_1step_CC_maskV_-1.0=0.66644365, learning_rate=0.001\n", + "Epoch 67/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29128942, rnn_1step_R2_maskV_-1.0=0.69953859, rnn_1step_CC_maskV_-1.0=0.84233105, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53520751, val_rnn_1step_R2_maskV_-1.0=0.37842664, val_rnn_1step_CC_maskV_-1.0=0.6779837, learning_rate=0.001\n", + "Epoch 78/105 - loss=rnn_1step_loss=0.25505349, rnn_1step_R2_maskV_-1.0=0.73708034, rnn_1step_CC_maskV_-1.0=0.86333799, rnn_1step_MSE_maskV_-1.0=0.25505346, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51426047, val_rnn_1step_R2_maskV_-1.0=0.40391752, val_rnn_1step_CC_maskV_-1.0=0.6963982, learning_rate=0.001\n", + "Epoch 89/105 - loss=rnn_1step_loss=0.23466402, rnn_1step_R2_maskV_-1.0=0.75800478, rnn_1step_CC_maskV_-1.0=0.87545842, rnn_1step_MSE_maskV_-1.0=0.23466404, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47852969, val_rnn_1step_R2_maskV_-1.0=0.44649702, val_rnn_1step_CC_maskV_-1.0=0.71545923, learning_rate=0.001\n", + "Epoch 100/105 - loss=rnn_1step_loss=0.21986397, rnn_1step_R2_maskV_-1.0=0.77335727, rnn_1step_CC_maskV_-1.0=0.88404942, rnn_1step_MSE_maskV_-1.0=0.21986398, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5020299, val_rnn_1step_R2_maskV_-1.0=0.41914877, val_rnn_1step_CC_maskV_-1.0=0.70730096, learning_rate=0.001\n", + "Epoch 105/105 - loss=rnn_1step_loss=0.2125023, rnn_1step_R2_maskV_-1.0=0.78072989, rnn_1step_CC_maskV_-1.0=0.88775742, rnn_1step_MSE_maskV_-1.0=0.21250229, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50561434, val_rnn_1step_R2_maskV_-1.0=0.41505405, val_rnn_1step_CC_maskV_-1.0=0.7089479, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:10:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.77s\n", + "\u001b[32m2025-05-30 16:10:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:11:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 116 (stopped at 131 epochs).\n", + "\u001b[32m2025-05-30 16:11:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/132 - loss=rnn_1_1step_loss=1.0014085, rnn_1_1step_R2_maskV_-1.0=-0.012679841, rnn_1_1step_CC_maskV_-1.0=0.13603376, rnn_1_1step_MSE_maskV_-1.0=1.0014086, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91615486, val_rnn_1_1step_R2_maskV_-1.0=-0.058149338, val_rnn_1_1step_CC_maskV_-1.0=0.30672851, learning_rate=0.001\n", + "Epoch 15/132 - loss=rnn_1_1step_loss=0.69591302, rnn_1_1step_R2_maskV_-1.0=0.29002631, rnn_1_1step_CC_maskV_-1.0=0.55232871, rnn_1_1step_MSE_maskV_-1.0=0.6959129, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.69442964, val_rnn_1_1step_R2_maskV_-1.0=0.19490345, val_rnn_1_1step_CC_maskV_-1.0=0.50489706, learning_rate=0.001\n", + "Epoch 29/132 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.53084993, rnn_1_1step_R2_maskV_-1.0=0.45479336, rnn_1_1step_CC_maskV_-1.0=0.68456978, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6302436, val_rnn_1_1step_R2_maskV_-1.0=0.26905179, val_rnn_1_1step_CC_maskV_-1.0=0.57405686, learning_rate=0.001\n", + "Epoch 43/132 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41616949, rnn_1_1step_R2_maskV_-1.0=0.57072759, rnn_1_1step_CC_maskV_-1.0=0.76382184, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58116585, val_rnn_1_1step_R2_maskV_-1.0=0.32557487, val_rnn_1_1step_CC_maskV_-1.0=0.62978613, learning_rate=0.001\n", + "Epoch 57/132 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33807263, rnn_1_1step_R2_maskV_-1.0=0.65040648, rnn_1_1step_CC_maskV_-1.0=0.81370676, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53578329, val_rnn_1_1step_R2_maskV_-1.0=0.37744683, val_rnn_1_1step_CC_maskV_-1.0=0.67094392, learning_rate=0.001\n", + "Epoch 71/132 - loss=rnn_1_1step_loss=0.2955811, rnn_1_1step_R2_maskV_-1.0=0.69425893, rnn_1_1step_CC_maskV_-1.0=0.83962768, rnn_1_1step_MSE_maskV_-1.0=0.29558113, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54062176, val_rnn_1_1step_R2_maskV_-1.0=0.37186757, val_rnn_1_1step_CC_maskV_-1.0=0.67595375, learning_rate=0.001\n", + "Epoch 85/132 - loss=rnn_1_1step_loss=0.25702217, rnn_1_1step_R2_maskV_-1.0=0.7345283, rnn_1_1step_CC_maskV_-1.0=0.86216688, rnn_1_1step_MSE_maskV_-1.0=0.2570222, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51717925, val_rnn_1_1step_R2_maskV_-1.0=0.40012643, val_rnn_1_1step_CC_maskV_-1.0=0.69288766, learning_rate=0.001\n", + "Epoch 99/132 - loss=rnn_1_1step_loss=0.22766662, rnn_1_1step_R2_maskV_-1.0=0.7655009, rnn_1_1step_CC_maskV_-1.0=0.87924445, rnn_1_1step_MSE_maskV_-1.0=0.22766663, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4984684, val_rnn_1_1step_R2_maskV_-1.0=0.42305306, val_rnn_1_1step_CC_maskV_-1.0=0.70272785, learning_rate=0.001\n", + "Epoch 113/132 - loss=rnn_1_1step_loss=0.20962413, rnn_1_1step_R2_maskV_-1.0=0.78388113, rnn_1_1step_CC_maskV_-1.0=0.88947064, rnn_1_1step_MSE_maskV_-1.0=0.20962411, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50950903, val_rnn_1_1step_R2_maskV_-1.0=0.41002053, val_rnn_1_1step_CC_maskV_-1.0=0.70110554, learning_rate=0.001\n", + "Epoch 127/132 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.20227166, rnn_1_1step_R2_maskV_-1.0=0.79179561, rnn_1_1step_CC_maskV_-1.0=0.89423269, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49171305, val_rnn_1_1step_R2_maskV_-1.0=0.4314543, val_rnn_1_1step_CC_maskV_-1.0=0.706249, learning_rate=0.001\n", + "Epoch 132/132 - loss=rnn_1_1step_loss=0.19561385, rnn_1_1step_R2_maskV_-1.0=0.79831243, rnn_1_1step_CC_maskV_-1.0=0.89691901, rnn_1_1step_MSE_maskV_-1.0=0.19561383, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50071794, val_rnn_1_1step_R2_maskV_-1.0=0.42047927, val_rnn_1_1step_CC_maskV_-1.0=0.70662683, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:11:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.37s\n", + "\u001b[32m2025-05-30 16:11:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.47852969)\n", + "\u001b[32m2025-05-30 16:11:06\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.215, R2_maskV_-1.0=0.786, CC_maskV_-1.0=0.887\n", + "\u001b[32m2025-05-30 16:11:06\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.441, R2_maskV_-1.0=0.502, CC_maskV_-1.0=0.743\n", + "\u001b[32m2025-05-30 16:11:06\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:11:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:12:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 196 (stopped at 211 epochs).\n", + "\u001b[32m2025-05-30 16:12:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/212 - loss=1.0329487, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.15026768, MSE_maskV_-1.0=1.0329988, val_loss=0.97939032, val_CC_maskV_-1.0=0.22231738, val_MSE_maskV_-1.0=0.97609413, learning_rate=0.001\n", + "Epoch 23/212 - loss=0.81414354, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43314987, MSE_maskV_-1.0=0.8134166, val_loss=0.8587001, val_CC_maskV_-1.0=0.40710929, val_MSE_maskV_-1.0=0.85607708, learning_rate=0.001\n", + "Epoch 45/212 - loss=0.77966791, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47004792, MSE_maskV_-1.0=0.77987099, val_loss=0.83092695, val_CC_maskV_-1.0=0.43500316, val_MSE_maskV_-1.0=0.82839352, learning_rate=0.001\n", + "Epoch 67/212 - loss=0.76171654, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48850319, MSE_maskV_-1.0=0.76153207, val_loss=0.81834644, val_CC_maskV_-1.0=0.44902682, val_MSE_maskV_-1.0=0.81567734, learning_rate=0.001\n", + "Epoch 89/212 - loss=0.75041616, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49919763, MSE_maskV_-1.0=0.74970537, val_loss=0.80469823, val_CC_maskV_-1.0=0.46090993, val_MSE_maskV_-1.0=0.80322981, learning_rate=0.001\n", + "Epoch 111/212 - loss=0.74205452, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50818348, MSE_maskV_-1.0=0.74180853, val_loss=0.80144596, val_CC_maskV_-1.0=0.46398041, val_MSE_maskV_-1.0=0.80055785, learning_rate=0.001\n", + "Epoch 133/212 - loss=0.7352016, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51377732, MSE_maskV_-1.0=0.73484105, val_loss=0.79388583, val_CC_maskV_-1.0=0.47193086, val_MSE_maskV_-1.0=0.79217613, learning_rate=0.001\n", + "Epoch 155/212 - loss=0.72960842, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51972157, MSE_maskV_-1.0=0.73023957, val_loss=0.79428995, val_CC_maskV_-1.0=0.47295067, val_MSE_maskV_-1.0=0.79197955, learning_rate=0.001\n", + "Epoch 177/212 - loss=0.72559202, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52306437, MSE_maskV_-1.0=0.72515583, val_loss=0.79251385, val_CC_maskV_-1.0=0.47511908, val_MSE_maskV_-1.0=0.79079092, learning_rate=0.001\n", + "Epoch 199/212 - loss=0.72173858, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52693003, MSE_maskV_-1.0=0.72163302, val_loss=0.7902202, val_CC_maskV_-1.0=0.47749487, val_MSE_maskV_-1.0=0.78834897, learning_rate=0.001\n", + "Epoch 212/212 - loss=0.72014409, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52873063, MSE_maskV_-1.0=0.71993011, val_loss=0.78723556, val_CC_maskV_-1.0=0.47949719, val_MSE_maskV_-1.0=0.78626454, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:12:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 54.03s\n", + "\u001b[32m2025-05-30 16:12:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:13:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 248 (stopped at 263 epochs).\n", + "\u001b[32m2025-05-30 16:13:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/264 - loss=1.0608203, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.13559751, MSE_maskV_-1.0=1.0609341, val_loss=0.98006308, val_CC_maskV_-1.0=0.21802932, val_MSE_maskV_-1.0=0.97853291, learning_rate=0.001\n", + "Epoch 28/264 - loss=0.80524451, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44286376, MSE_maskV_-1.0=0.80577272, val_loss=0.85423535, val_CC_maskV_-1.0=0.41244745, val_MSE_maskV_-1.0=0.85116172, learning_rate=0.001\n", + "Epoch 55/264 - loss=0.7734164, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47659588, MSE_maskV_-1.0=0.773045, val_loss=0.82656664, val_CC_maskV_-1.0=0.44016501, val_MSE_maskV_-1.0=0.82437593, learning_rate=0.001\n", + "Epoch 82/264 - loss=0.75716001, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49218613, MSE_maskV_-1.0=0.75757897, val_loss=0.80482173, val_CC_maskV_-1.0=0.46038452, val_MSE_maskV_-1.0=0.802764, learning_rate=0.001\n", + "Epoch 109/264 - loss=0.74670559, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50265813, MSE_maskV_-1.0=0.74626696, val_loss=0.7972905, val_CC_maskV_-1.0=0.46813348, val_MSE_maskV_-1.0=0.79555517, learning_rate=0.001\n", + "Epoch 136/264 - loss=0.73886311, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51116788, MSE_maskV_-1.0=0.73940128, val_loss=0.79796183, val_CC_maskV_-1.0=0.46850806, val_MSE_maskV_-1.0=0.79644459, learning_rate=0.001\n", + "Epoch 163/264 - loss=0.73289132, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51654267, MSE_maskV_-1.0=0.73295379, val_loss=0.79159147, val_CC_maskV_-1.0=0.4744049, val_MSE_maskV_-1.0=0.78979003, learning_rate=0.001\n", + "Epoch 190/264 - loss=0.727907, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52109343, MSE_maskV_-1.0=0.72862309, val_loss=0.79422474, val_CC_maskV_-1.0=0.47341973, val_MSE_maskV_-1.0=0.79155332, learning_rate=0.001\n", + "Epoch 217/264 - loss=0.72419053, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52454174, MSE_maskV_-1.0=0.72346354, val_loss=0.78932154, val_CC_maskV_-1.0=0.47730753, val_MSE_maskV_-1.0=0.78710198, learning_rate=0.001\n", + "Epoch 244/264 - loss=0.7214129, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52642965, MSE_maskV_-1.0=0.72175562, val_loss=0.7886833, val_CC_maskV_-1.0=0.47816777, val_MSE_maskV_-1.0=0.78658742, learning_rate=0.001\n", + "Epoch 264/264 - loss=0.7193867, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52927369, MSE_maskV_-1.0=0.72058022, val_loss=0.7892735, val_CC_maskV_-1.0=0.47919682, val_MSE_maskV_-1.0=0.78666276, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:13:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 67.17s\n", + "\u001b[32m2025-05-30 16:13:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.78485972)\n", + "\u001b[32m2025-05-30 16:13:07\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 752us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:13:08\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.717, R2_maskV_-1.0=0.284, CC_maskV_-1.0=0.532\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 748us/step\n", + "51/51 [==============================] - 0s 753us/step\n", + "84/84 [==============================] - 0s 778us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:13:08\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_uAKCy1HL64U_ErSV16\" (13/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_uAKCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:13:08\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_ACzCy1HL64U_ErSV16\" (14/16)\n", + "\u001b[32m2025-05-30 16:13:08\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:13:08\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:13:09\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:13:09\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:13:09\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:13:09\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:13:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:13:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 60 (stopped at 75 epochs).\n", + "\u001b[32m2025-05-30 16:13:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/76 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.001158, rnn_1step_R2_maskV_-1.0=-0.012431964, rnn_1step_CC_maskV_-1.0=0.13735799, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91613865, val_rnn_1step_R2_maskV_-1.0=-0.058074206, val_rnn_1step_CC_maskV_-1.0=0.27943274, learning_rate=0.001\n", + "Epoch 9/76 - loss=rnn_1step_loss=0.89276314, rnn_1step_R2_maskV_-1.0=0.097500198, rnn_1step_CC_maskV_-1.0=0.39334017, rnn_1step_MSE_maskV_-1.0=0.89276308, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.83076984, val_rnn_1step_R2_maskV_-1.0=0.037183404, val_rnn_1step_CC_maskV_-1.0=0.35752875, learning_rate=0.001\n", + "Epoch 17/76 - loss=rnn_1step_loss=0.70792776, rnn_1step_R2_maskV_-1.0=0.27954146, rnn_1step_CC_maskV_-1.0=0.54323953, rnn_1step_MSE_maskV_-1.0=0.70792782, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.67513371, val_rnn_1step_R2_maskV_-1.0=0.21590871, val_rnn_1step_CC_maskV_-1.0=0.52089667, learning_rate=0.001\n", + "Epoch 25/76 - loss=rnn_1step_loss=0.61357373, rnn_1step_R2_maskV_-1.0=0.37352484, rnn_1step_CC_maskV_-1.0=0.62272191, rnn_1step_MSE_maskV_-1.0=0.61357367, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.65329963, val_rnn_1step_R2_maskV_-1.0=0.24166219, val_rnn_1step_CC_maskV_-1.0=0.54708594, learning_rate=0.001\n", + "Epoch 33/76 - loss=rnn_1step_loss=0.5535503, rnn_1step_R2_maskV_-1.0=0.43371999, rnn_1step_CC_maskV_-1.0=0.66853732, rnn_1step_MSE_maskV_-1.0=0.55355024, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63515544, val_rnn_1step_R2_maskV_-1.0=0.26235065, val_rnn_1step_CC_maskV_-1.0=0.57286459, learning_rate=0.001\n", + "Epoch 41/76 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.50940907, rnn_1step_R2_maskV_-1.0=0.47808796, rnn_1step_CC_maskV_-1.0=0.70081484, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62379771, val_rnn_1step_R2_maskV_-1.0=0.27524167, val_rnn_1step_CC_maskV_-1.0=0.59122521, learning_rate=0.001\n", + "Epoch 49/76 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.47621012, rnn_1step_R2_maskV_-1.0=0.51119155, rnn_1step_CC_maskV_-1.0=0.72388911, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6191209, val_rnn_1step_R2_maskV_-1.0=0.28068185, val_rnn_1step_CC_maskV_-1.0=0.59919292, learning_rate=0.001\n", + "Epoch 57/76 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.45359099, rnn_1step_R2_maskV_-1.0=0.53371477, rnn_1step_CC_maskV_-1.0=0.73914242, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63483393, val_rnn_1step_R2_maskV_-1.0=0.26269948, val_rnn_1step_CC_maskV_-1.0=0.59219927, learning_rate=0.001\n", + "Epoch 65/76 - loss=rnn_1step_loss=0.43551555, rnn_1step_R2_maskV_-1.0=0.55162132, rnn_1step_CC_maskV_-1.0=0.75114208, rnn_1step_MSE_maskV_-1.0=0.43551558, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.65904641, val_rnn_1step_R2_maskV_-1.0=0.23417903, val_rnn_1step_CC_maskV_-1.0=0.58352232, learning_rate=0.001\n", + "Epoch 73/76 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4224768, rnn_1step_R2_maskV_-1.0=0.56453896, rnn_1step_CC_maskV_-1.0=0.75980359, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6602428, val_rnn_1step_R2_maskV_-1.0=0.23311903, val_rnn_1step_CC_maskV_-1.0=0.5863983, learning_rate=0.001\n", + "Epoch 76/76 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41812095, rnn_1step_R2_maskV_-1.0=0.5690285, rnn_1step_CC_maskV_-1.0=0.7626521, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64818925, val_rnn_1step_R2_maskV_-1.0=0.24723054, val_rnn_1step_CC_maskV_-1.0=0.59124702, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:13:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 10.27s\n", + "\u001b[32m2025-05-30 16:13:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:13:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 47 (stopped at 62 epochs).\n", + "\u001b[32m2025-05-30 16:13:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/63 - loss=rnn_1_1step_loss=1.0022105, rnn_1_1step_R2_maskV_-1.0=-0.013522543, rnn_1_1step_CC_maskV_-1.0=0.036035266, rnn_1_1step_MSE_maskV_-1.0=1.0022104, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91773719, val_rnn_1_1step_R2_maskV_-1.0=-0.059957683, val_rnn_1_1step_CC_maskV_-1.0=0.20286889, learning_rate=0.001\n", + "Epoch 8/63 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.95346087, rnn_1_1step_R2_maskV_-1.0=0.036502883, rnn_1_1step_CC_maskV_-1.0=0.40726474, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.87384629, val_rnn_1_1step_R2_maskV_-1.0=-0.010681331, val_rnn_1_1step_CC_maskV_-1.0=0.33950731, learning_rate=0.001\n", + "Epoch 15/63 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.74245977, rnn_1_1step_R2_maskV_-1.0=0.24760482, rnn_1_1step_CC_maskV_-1.0=0.51661056, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.72443503, val_rnn_1_1step_R2_maskV_-1.0=0.15808079, val_rnn_1_1step_CC_maskV_-1.0=0.4642683, learning_rate=0.001\n", + "Epoch 22/63 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.61218065, rnn_1_1step_R2_maskV_-1.0=0.3757453, rnn_1_1step_CC_maskV_-1.0=0.62339723, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.6656478, val_rnn_1_1step_R2_maskV_-1.0=0.22818381, val_rnn_1_1step_CC_maskV_-1.0=0.54226273, learning_rate=0.001\n", + "Epoch 29/63 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.54301947, rnn_1_1step_R2_maskV_-1.0=0.44475377, rnn_1_1step_CC_maskV_-1.0=0.67564529, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64491349, val_rnn_1_1step_R2_maskV_-1.0=0.25384322, val_rnn_1_1step_CC_maskV_-1.0=0.56915611, learning_rate=0.001\n", + "Epoch 36/63 - loss=rnn_1_1step_loss=0.50510353, rnn_1_1step_R2_maskV_-1.0=0.48269242, rnn_1_1step_CC_maskV_-1.0=0.70301956, rnn_1_1step_MSE_maskV_-1.0=0.50510359, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63565153, val_rnn_1_1step_R2_maskV_-1.0=0.26473165, val_rnn_1_1step_CC_maskV_-1.0=0.58637375, learning_rate=0.001\n", + "Epoch 43/63 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.47792748, rnn_1_1step_R2_maskV_-1.0=0.5098905, rnn_1_1step_CC_maskV_-1.0=0.7222203, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62183589, val_rnn_1_1step_R2_maskV_-1.0=0.28030473, val_rnn_1_1step_CC_maskV_-1.0=0.59924424, learning_rate=0.001\n", + "Epoch 50/63 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.45614624, rnn_1_1step_R2_maskV_-1.0=0.53142166, rnn_1_1step_CC_maskV_-1.0=0.73707175, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62443674, val_rnn_1_1step_R2_maskV_-1.0=0.27647227, val_rnn_1_1step_CC_maskV_-1.0=0.60514927, learning_rate=0.001\n", + "Epoch 57/63 - loss=rnn_1_1step_loss=0.43578267, rnn_1_1step_R2_maskV_-1.0=0.55162996, rnn_1_1step_CC_maskV_-1.0=0.75065112, rnn_1_1step_MSE_maskV_-1.0=0.43578264, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63283283, val_rnn_1_1step_R2_maskV_-1.0=0.26620209, val_rnn_1_1step_CC_maskV_-1.0=0.60647899, learning_rate=0.001\n", + "Epoch 63/63 - loss=rnn_1_1step_loss=0.41762415, rnn_1_1step_R2_maskV_-1.0=0.56975639, rnn_1_1step_CC_maskV_-1.0=0.76268232, rnn_1_1step_MSE_maskV_-1.0=0.41762418, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64008886, val_rnn_1_1step_R2_maskV_-1.0=0.25776565, val_rnn_1_1step_CC_maskV_-1.0=0.60778856, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:13:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 9.00s\n", + "\u001b[32m2025-05-30 16:13:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.61273068)\n", + "\u001b[32m2025-05-30 16:13:30\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.431, R2_maskV_-1.0=0.568, CC_maskV_-1.0=0.755\n", + "\u001b[32m2025-05-30 16:13:30\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.599, R2_maskV_-1.0=0.321, CC_maskV_-1.0=0.621\n", + "\u001b[32m2025-05-30 16:13:30\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:13:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:14:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 139 (stopped at 154 epochs).\n", + "\u001b[32m2025-05-30 16:14:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/155 - loss=0.9754535, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.24260765, MSE_maskV_-1.0=0.97551459, val_loss=0.88986129, val_CC_maskV_-1.0=0.36351234, val_MSE_maskV_-1.0=0.88586456, learning_rate=0.001\n", + "Epoch 17/155 - loss=0.65922254, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58303797, MSE_maskV_-1.0=0.65911448, val_loss=0.69584596, val_CC_maskV_-1.0=0.56286943, val_MSE_maskV_-1.0=0.69328839, learning_rate=0.001\n", + "Epoch 33/155 - loss=0.62831396, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60831463, MSE_maskV_-1.0=0.62823409, val_loss=0.66982502, val_CC_maskV_-1.0=0.58381271, val_MSE_maskV_-1.0=0.6671437, learning_rate=0.001\n", + "Epoch 49/155 - loss=0.61402512, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61980253, MSE_maskV_-1.0=0.61390102, val_loss=0.65893948, val_CC_maskV_-1.0=0.59294462, val_MSE_maskV_-1.0=0.65539044, learning_rate=0.001\n", + "Epoch 65/155 - loss=0.60594696, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6252526, MSE_maskV_-1.0=0.60552084, val_loss=0.65189779, val_CC_maskV_-1.0=0.59879619, val_MSE_maskV_-1.0=0.64866906, learning_rate=0.001\n", + "Epoch 81/155 - loss=0.59946603, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63051569, MSE_maskV_-1.0=0.59979045, val_loss=0.64627171, val_CC_maskV_-1.0=0.60355252, val_MSE_maskV_-1.0=0.64292169, learning_rate=0.001\n", + "Epoch 97/155 - loss=0.59430611, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63477111, MSE_maskV_-1.0=0.5949415, val_loss=0.64499426, val_CC_maskV_-1.0=0.60467333, val_MSE_maskV_-1.0=0.64174742, learning_rate=0.001\n", + "Epoch 113/155 - loss=0.59004557, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63789976, MSE_maskV_-1.0=0.59124732, val_loss=0.64399028, val_CC_maskV_-1.0=0.60648632, val_MSE_maskV_-1.0=0.64028406, learning_rate=0.001\n", + "Epoch 129/155 - loss=0.58664405, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63988471, MSE_maskV_-1.0=0.58679599, val_loss=0.63982475, val_CC_maskV_-1.0=0.60970986, val_MSE_maskV_-1.0=0.63618141, learning_rate=0.001\n", + "Epoch 145/155 - loss=0.58400828, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64185041, MSE_maskV_-1.0=0.58377838, val_loss=0.63858652, val_CC_maskV_-1.0=0.61040181, val_MSE_maskV_-1.0=0.63533425, learning_rate=0.001\n", + "Epoch 155/155 - loss=0.5817188, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64433062, MSE_maskV_-1.0=0.58218306, val_loss=0.63912278, val_CC_maskV_-1.0=0.61135846, val_MSE_maskV_-1.0=0.63549399, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:14:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 39.97s\n", + "\u001b[32m2025-05-30 16:14:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:15:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 198 (stopped at 213 epochs).\n", + "\u001b[32m2025-05-30 16:15:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/214 - loss=0.96018219, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.24919556, MSE_maskV_-1.0=0.96030861, val_loss=0.89286828, val_CC_maskV_-1.0=0.35922626, val_MSE_maskV_-1.0=0.88981855, learning_rate=0.001\n", + "Epoch 23/214 - loss=0.63855886, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60017067, MSE_maskV_-1.0=0.63799137, val_loss=0.67941952, val_CC_maskV_-1.0=0.57800692, val_MSE_maskV_-1.0=0.67652744, learning_rate=0.001\n", + "Epoch 45/214 - loss=0.61564475, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61744809, MSE_maskV_-1.0=0.61578268, val_loss=0.66581637, val_CC_maskV_-1.0=0.5887537, val_MSE_maskV_-1.0=0.66285247, learning_rate=0.001\n", + "Epoch 67/214 - loss=0.60418832, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62735975, MSE_maskV_-1.0=0.60411984, val_loss=0.6620487, val_CC_maskV_-1.0=0.59221429, val_MSE_maskV_-1.0=0.65844691, learning_rate=0.001\n", + "Epoch 89/214 - loss=0.59701705, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63173997, MSE_maskV_-1.0=0.59637123, val_loss=0.65359545, val_CC_maskV_-1.0=0.59878534, val_MSE_maskV_-1.0=0.65035141, learning_rate=0.001\n", + "Epoch 111/214 - loss=0.59151638, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6367349, MSE_maskV_-1.0=0.59154129, val_loss=0.64835954, val_CC_maskV_-1.0=0.60221803, val_MSE_maskV_-1.0=0.64497989, learning_rate=0.001\n", + "Epoch 133/214 - loss=0.58739763, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.63920021, MSE_maskV_-1.0=0.58736151, val_loss=0.64583486, val_CC_maskV_-1.0=0.60510224, val_MSE_maskV_-1.0=0.64199048, learning_rate=0.001\n", + "Epoch 155/214 - loss=0.58346325, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64306021, MSE_maskV_-1.0=0.58390719, val_loss=0.64456314, val_CC_maskV_-1.0=0.60627854, val_MSE_maskV_-1.0=0.6406914, learning_rate=0.001\n", + "Epoch 177/214 - loss=0.58064687, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64498037, MSE_maskV_-1.0=0.58040541, val_loss=0.6401571, val_CC_maskV_-1.0=0.60902125, val_MSE_maskV_-1.0=0.63636732, learning_rate=0.001\n", + "Epoch 199/214 - loss=0.57826161, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64666295, MSE_maskV_-1.0=0.57877648, val_loss=0.64049327, val_CC_maskV_-1.0=0.6098004, val_MSE_maskV_-1.0=0.6367774, learning_rate=0.001\n", + "Epoch 214/214 - loss=0.57682037, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.64724582, MSE_maskV_-1.0=0.57709682, val_loss=0.63895279, val_CC_maskV_-1.0=0.61051297, val_MSE_maskV_-1.0=0.6352157, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:15:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 54.03s\n", + "\u001b[32m2025-05-30 16:15:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.63711298)\n", + "\u001b[32m2025-05-30 16:15:04\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 759us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:15:04\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.573, R2_maskV_-1.0=0.429, CC_maskV_-1.0=0.653\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 838us/step\n", + "51/51 [==============================] - 0s 701us/step\n", + "84/84 [==============================] - 0s 738us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:15:05\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_ACzCy1HL64U_ErSV16\" (14/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_ACzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:15:05\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_KCzCy1HL64U_ErSV16\" (15/16)\n", + "\u001b[32m2025-05-30 16:15:05\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:15:05\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:15:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:15:05\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:15:05\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:15:05\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:15:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:15:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 80 (stopped at 95 epochs).\n", + "\u001b[32m2025-05-30 16:15:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/96 - loss=rnn_1step_loss=1.0023333, rnn_1step_R2_maskV_-1.0=-0.013663862, rnn_1step_CC_maskV_-1.0=0.035477497, rnn_1step_MSE_maskV_-1.0=1.0023332, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91774923, val_rnn_1step_R2_maskV_-1.0=-0.05991599, val_rnn_1step_CC_maskV_-1.0=0.27456442, learning_rate=0.001\n", + "Epoch 11/96 - loss=rnn_1step_loss=0.87496418, rnn_1step_R2_maskV_-1.0=0.11425114, rnn_1step_CC_maskV_-1.0=0.35865951, rnn_1step_MSE_maskV_-1.0=0.87496412, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.76724178, val_rnn_1step_R2_maskV_-1.0=0.11484657, val_rnn_1step_CC_maskV_-1.0=0.40617561, learning_rate=0.001\n", + "Epoch 21/96 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.63837904, rnn_1step_R2_maskV_-1.0=0.34883133, rnn_1step_CC_maskV_-1.0=0.60428125, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63691837, val_rnn_1step_R2_maskV_-1.0=0.26294631, val_rnn_1step_CC_maskV_-1.0=0.55693382, learning_rate=0.001\n", + "Epoch 31/96 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.52477741, rnn_1step_R2_maskV_-1.0=0.46324059, rnn_1step_CC_maskV_-1.0=0.69076711, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59654099, val_rnn_1step_R2_maskV_-1.0=0.30786395, val_rnn_1step_CC_maskV_-1.0=0.59953898, learning_rate=0.001\n", + "Epoch 41/96 - loss=rnn_1step_loss=0.4414793, rnn_1step_R2_maskV_-1.0=0.54777026, rnn_1step_CC_maskV_-1.0=0.74790567, rnn_1step_MSE_maskV_-1.0=0.44147933, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57193685, val_rnn_1step_R2_maskV_-1.0=0.33522457, val_rnn_1step_CC_maskV_-1.0=0.63150972, learning_rate=0.001\n", + "Epoch 51/96 - loss=rnn_1step_loss=0.38525018, rnn_1step_R2_maskV_-1.0=0.60456485, rnn_1step_CC_maskV_-1.0=0.78435653, rnn_1step_MSE_maskV_-1.0=0.38525021, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54581529, val_rnn_1step_R2_maskV_-1.0=0.36632651, val_rnn_1step_CC_maskV_-1.0=0.65971047, learning_rate=0.001\n", + "Epoch 61/96 - loss=rnn_1step_loss=0.34952173, rnn_1step_R2_maskV_-1.0=0.64087152, rnn_1step_CC_maskV_-1.0=0.80659926, rnn_1step_MSE_maskV_-1.0=0.3495217, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53299576, val_rnn_1step_R2_maskV_-1.0=0.38164681, val_rnn_1step_CC_maskV_-1.0=0.67257196, learning_rate=0.001\n", + "Epoch 71/96 - loss=rnn_1step_loss=0.31979573, rnn_1step_R2_maskV_-1.0=0.67114508, rnn_1step_CC_maskV_-1.0=0.82478708, rnn_1step_MSE_maskV_-1.0=0.3197957, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52705795, val_rnn_1step_R2_maskV_-1.0=0.38883471, val_rnn_1step_CC_maskV_-1.0=0.67841035, learning_rate=0.001\n", + "Epoch 81/96 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29866609, rnn_1step_R2_maskV_-1.0=0.69222355, rnn_1step_CC_maskV_-1.0=0.83790237, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51626229, val_rnn_1step_R2_maskV_-1.0=0.40196583, val_rnn_1step_CC_maskV_-1.0=0.68305814, learning_rate=0.001\n", + "Epoch 91/96 - loss=rnn_1step_loss=0.27248296, rnn_1step_R2_maskV_-1.0=0.71918392, rnn_1step_CC_maskV_-1.0=0.85317743, rnn_1step_MSE_maskV_-1.0=0.27248293, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51829559, val_rnn_1step_R2_maskV_-1.0=0.39976165, val_rnn_1step_CC_maskV_-1.0=0.68502539, learning_rate=0.001\n", + "Epoch 96/96 - loss=rnn_1step_loss=0.26400447, rnn_1step_R2_maskV_-1.0=0.7278704, rnn_1step_CC_maskV_-1.0=0.85789657, rnn_1step_MSE_maskV_-1.0=0.26400444, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53496665, val_rnn_1step_R2_maskV_-1.0=0.3797555, val_rnn_1step_CC_maskV_-1.0=0.67896897, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:15:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 11.79s\n", + "\u001b[32m2025-05-30 16:15:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:15:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 105 (stopped at 120 epochs).\n", + "\u001b[32m2025-05-30 16:15:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/121 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0022916, rnn_1_1step_R2_maskV_-1.0=-0.013620853, rnn_1_1step_CC_maskV_-1.0=0.059641033, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.918073, val_rnn_1_1step_R2_maskV_-1.0=-0.060316056, val_rnn_1_1step_CC_maskV_-1.0=0.29861218, learning_rate=0.001\n", + "Epoch 14/121 - loss=rnn_1_1step_loss=0.77170104, rnn_1_1step_R2_maskV_-1.0=0.2169629, rnn_1_1step_CC_maskV_-1.0=0.4832297, rnn_1_1step_MSE_maskV_-1.0=0.77170098, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.74212503, val_rnn_1_1step_R2_maskV_-1.0=0.1401889, val_rnn_1_1step_CC_maskV_-1.0=0.44076809, learning_rate=0.001\n", + "Epoch 27/121 - loss=rnn_1_1step_loss=0.54599792, rnn_1_1step_R2_maskV_-1.0=0.44168517, rnn_1_1step_CC_maskV_-1.0=0.67311341, rnn_1_1step_MSE_maskV_-1.0=0.54599798, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65004963, val_rnn_1_1step_R2_maskV_-1.0=0.24693635, val_rnn_1_1step_CC_maskV_-1.0=0.56817919, learning_rate=0.001\n", + "Epoch 40/121 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44732013, rnn_1_1step_R2_maskV_-1.0=0.54060721, rnn_1_1step_CC_maskV_-1.0=0.74315393, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58031982, val_rnn_1_1step_R2_maskV_-1.0=0.32466125, val_rnn_1_1step_CC_maskV_-1.0=0.63273072, learning_rate=0.001\n", + "Epoch 53/121 - loss=rnn_1_1step_loss=0.3931624, rnn_1_1step_R2_maskV_-1.0=0.59503996, rnn_1_1step_CC_maskV_-1.0=0.77907288, rnn_1_1step_MSE_maskV_-1.0=0.39316237, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55310249, val_rnn_1_1step_R2_maskV_-1.0=0.3563444, val_rnn_1_1step_CC_maskV_-1.0=0.66236675, learning_rate=0.001\n", + "Epoch 66/121 - loss=rnn_1_1step_loss=0.34221229, rnn_1_1step_R2_maskV_-1.0=0.64686638, rnn_1_1step_CC_maskV_-1.0=0.81097323, rnn_1_1step_MSE_maskV_-1.0=0.34221226, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53191805, val_rnn_1_1step_R2_maskV_-1.0=0.38159311, val_rnn_1_1step_CC_maskV_-1.0=0.6844781, learning_rate=0.001\n", + "Epoch 79/121 - loss=rnn_1_1step_loss=0.309811, rnn_1_1step_R2_maskV_-1.0=0.67999738, rnn_1_1step_CC_maskV_-1.0=0.83050287, rnn_1_1step_MSE_maskV_-1.0=0.30981097, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51648295, val_rnn_1_1step_R2_maskV_-1.0=0.39972037, val_rnn_1_1step_CC_maskV_-1.0=0.69515353, learning_rate=0.001\n", + "Epoch 92/121 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.28624508, rnn_1_1step_R2_maskV_-1.0=0.70440245, rnn_1_1step_CC_maskV_-1.0=0.84461999, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50233793, val_rnn_1_1step_R2_maskV_-1.0=0.41626871, val_rnn_1_1step_CC_maskV_-1.0=0.70348245, learning_rate=0.001\n", + "Epoch 105/121 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.26554328, rnn_1_1step_R2_maskV_-1.0=0.72565609, rnn_1_1step_CC_maskV_-1.0=0.85684663, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48911753, val_rnn_1_1step_R2_maskV_-1.0=0.43159011, val_rnn_1_1step_CC_maskV_-1.0=0.70990378, learning_rate=0.001\n", + "Epoch 118/121 - loss=rnn_1_1step_loss=0.24706967, rnn_1_1step_R2_maskV_-1.0=0.74491835, rnn_1_1step_CC_maskV_-1.0=0.86758518, rnn_1_1step_MSE_maskV_-1.0=0.24706969, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49832067, val_rnn_1_1step_R2_maskV_-1.0=0.42047706, val_rnn_1_1step_CC_maskV_-1.0=0.71087295, learning_rate=0.001\n", + "Epoch 121/121 - loss=rnn_1_1step_loss=0.24155651, rnn_1_1step_R2_maskV_-1.0=0.75031245, rnn_1_1step_CC_maskV_-1.0=0.87079406, rnn_1_1step_MSE_maskV_-1.0=0.2415565, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51378661, val_rnn_1_1step_R2_maskV_-1.0=0.40213254, val_rnn_1_1step_CC_maskV_-1.0=0.70664501, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:15:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.03s\n", + "\u001b[32m2025-05-30 16:15:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.48911753)\n", + "\u001b[32m2025-05-30 16:15:32\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.245, R2_maskV_-1.0=0.755, CC_maskV_-1.0=0.869\n", + "\u001b[32m2025-05-30 16:15:33\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.459, R2_maskV_-1.0=0.478, CC_maskV_-1.0=0.733\n", + "\u001b[32m2025-05-30 16:15:33\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:15:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:16:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 172 (stopped at 187 epochs).\n", + "\u001b[32m2025-05-30 16:16:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/188 - loss=1.2018387, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.12971003, MSE_maskV_-1.0=1.2015313, val_loss=0.97649002, val_CC_maskV_-1.0=0.23538025, val_MSE_maskV_-1.0=0.97287232, learning_rate=0.001\n", + "Epoch 20/188 - loss=0.80430782, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44356456, MSE_maskV_-1.0=0.8042087, val_loss=0.83757085, val_CC_maskV_-1.0=0.43667084, val_MSE_maskV_-1.0=0.83389568, learning_rate=0.001\n", + "Epoch 39/188 - loss=0.77607018, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47427714, MSE_maskV_-1.0=0.77599657, val_loss=0.81627655, val_CC_maskV_-1.0=0.45742196, val_MSE_maskV_-1.0=0.81338227, learning_rate=0.001\n", + "Epoch 58/188 - loss=0.7591691, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49100316, MSE_maskV_-1.0=0.75948203, val_loss=0.80397564, val_CC_maskV_-1.0=0.46992582, val_MSE_maskV_-1.0=0.80127442, learning_rate=0.001\n", + "Epoch 77/188 - loss=0.7497465, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50112218, MSE_maskV_-1.0=0.74919534, val_loss=0.79178613, val_CC_maskV_-1.0=0.48137486, val_MSE_maskV_-1.0=0.78913319, learning_rate=0.001\n", + "Epoch 96/188 - loss=0.74222887, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5080899, MSE_maskV_-1.0=0.74212611, val_loss=0.78584993, val_CC_maskV_-1.0=0.48685867, val_MSE_maskV_-1.0=0.78338504, learning_rate=0.001\n", + "Epoch 115/188 - loss=0.73762417, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5131911, MSE_maskV_-1.0=0.73737329, val_loss=0.78138882, val_CC_maskV_-1.0=0.49092451, val_MSE_maskV_-1.0=0.77863604, learning_rate=0.001\n", + "Epoch 134/188 - loss=0.73304588, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51704037, MSE_maskV_-1.0=0.73439211, val_loss=0.77331352, val_CC_maskV_-1.0=0.49827459, val_MSE_maskV_-1.0=0.7705937, learning_rate=0.001\n", + "Epoch 153/188 - loss=0.72955734, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52057016, MSE_maskV_-1.0=0.73018217, val_loss=0.77230811, val_CC_maskV_-1.0=0.49930134, val_MSE_maskV_-1.0=0.76957357, learning_rate=0.001\n", + "Epoch 172/188 - loss=0.72562319, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52382129, MSE_maskV_-1.0=0.72646672, val_loss=0.76412916, val_CC_maskV_-1.0=0.50654304, val_MSE_maskV_-1.0=0.76104796, learning_rate=0.001\n", + "Epoch 188/188 - loss=0.72365528, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52562571, MSE_maskV_-1.0=0.72259098, val_loss=0.76748425, val_CC_maskV_-1.0=0.50368744, val_MSE_maskV_-1.0=0.76456147, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:16:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 47.82s\n", + "\u001b[32m2025-05-30 16:16:20\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:17:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 172 (stopped at 187 epochs).\n", + "\u001b[32m2025-05-30 16:17:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/188 - loss=1.3287143, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.11235059, MSE_maskV_-1.0=1.3279177, val_loss=1.002676, val_CC_maskV_-1.0=0.19103342, val_MSE_maskV_-1.0=1.0004112, learning_rate=0.001\n", + "Epoch 20/188 - loss=0.80992872, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43709189, MSE_maskV_-1.0=0.80979759, val_loss=0.84706217, val_CC_maskV_-1.0=0.42644599, val_MSE_maskV_-1.0=0.84299004, learning_rate=0.001\n", + "Epoch 39/188 - loss=0.77959865, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47062904, MSE_maskV_-1.0=0.77952427, val_loss=0.81749421, val_CC_maskV_-1.0=0.45706838, val_MSE_maskV_-1.0=0.81402814, learning_rate=0.001\n", + "Epoch 58/188 - loss=0.75889736, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49127376, MSE_maskV_-1.0=0.75916672, val_loss=0.80132681, val_CC_maskV_-1.0=0.47331771, val_MSE_maskV_-1.0=0.79784107, learning_rate=0.001\n", + "Epoch 77/188 - loss=0.74805146, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50279564, MSE_maskV_-1.0=0.74742913, val_loss=0.79019153, val_CC_maskV_-1.0=0.4839634, val_MSE_maskV_-1.0=0.78611237, learning_rate=0.001\n", + "Epoch 96/188 - loss=0.73915058, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51124758, MSE_maskV_-1.0=0.73900318, val_loss=0.78426987, val_CC_maskV_-1.0=0.48836821, val_MSE_maskV_-1.0=0.78061527, learning_rate=0.001\n", + "Epoch 115/188 - loss=0.73348016, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51686454, MSE_maskV_-1.0=0.73330355, val_loss=0.77806777, val_CC_maskV_-1.0=0.49396828, val_MSE_maskV_-1.0=0.77440006, learning_rate=0.001\n", + "Epoch 134/188 - loss=0.72875524, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52097678, MSE_maskV_-1.0=0.73003268, val_loss=0.76887161, val_CC_maskV_-1.0=0.50250173, val_MSE_maskV_-1.0=0.76503783, learning_rate=0.001\n", + "Epoch 153/188 - loss=0.72438538, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52551234, MSE_maskV_-1.0=0.72506875, val_loss=0.76567441, val_CC_maskV_-1.0=0.50468427, val_MSE_maskV_-1.0=0.76179117, learning_rate=0.001\n", + "Epoch 172/188 - loss=0.72088879, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52815545, MSE_maskV_-1.0=0.72200572, val_loss=0.75866663, val_CC_maskV_-1.0=0.51032352, val_MSE_maskV_-1.0=0.75490069, learning_rate=0.001\n", + "Epoch 188/188 - loss=0.71881795, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52972692, MSE_maskV_-1.0=0.71781421, val_loss=0.76541108, val_CC_maskV_-1.0=0.50564045, val_MSE_maskV_-1.0=0.76101106, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:17:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 48.30s\n", + "\u001b[32m2025-05-30 16:17:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.75866663)\n", + "\u001b[32m2025-05-30 16:17:09\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 792us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:17:09\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.715, R2_maskV_-1.0=0.285, CC_maskV_-1.0=0.534\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 770us/step\n", + "51/51 [==============================] - 0s 982us/step\n", + "84/84 [==============================] - 0s 706us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:17:10\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_KCzCy1HL64U_ErSV16\" (15/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_KCzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:17:10\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 3/4 method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16\" (16/16)\n", + "\u001b[32m2025-05-30 16:17:10\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:17:10\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:17:10\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:17:10\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:17:10\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:17:10\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:17:10\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:17:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 151 (stopped at 166 epochs).\n", + "\u001b[32m2025-05-30 16:17:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0023152, rnn_1step_R2_maskV_-1.0=-0.01364255, rnn_1step_CC_maskV_-1.0=0.042693451, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.91820282, val_rnn_1step_R2_maskV_-1.0=-0.060476899, val_rnn_1step_CC_maskV_-1.0=0.3350324, learning_rate=0.001\n", + "Epoch 18/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.69121885, rnn_1step_R2_maskV_-1.0=0.29295, rnn_1step_CC_maskV_-1.0=0.55826575, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.69586426, val_rnn_1step_R2_maskV_-1.0=0.19268015, val_rnn_1step_CC_maskV_-1.0=0.50409895, learning_rate=0.001\n", + "Epoch 35/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.5395543, rnn_1step_R2_maskV_-1.0=0.44520682, rnn_1step_CC_maskV_-1.0=0.67878383, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63690257, val_rnn_1step_R2_maskV_-1.0=0.26111263, val_rnn_1step_CC_maskV_-1.0=0.56969047, learning_rate=0.001\n", + "Epoch 52/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.44173026, rnn_1step_R2_maskV_-1.0=0.54426479, rnn_1step_CC_maskV_-1.0=0.74720085, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57995528, val_rnn_1step_R2_maskV_-1.0=0.32733864, val_rnn_1step_CC_maskV_-1.0=0.6262176, learning_rate=0.001\n", + "Epoch 69/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.36624527, rnn_1step_R2_maskV_-1.0=0.62088162, rnn_1step_CC_maskV_-1.0=0.79588491, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.56237471, val_rnn_1step_R2_maskV_-1.0=0.34715304, val_rnn_1step_CC_maskV_-1.0=0.65037245, learning_rate=0.001\n", + "Epoch 86/167 - loss=rnn_1step_loss=0.33056334, rnn_1step_R2_maskV_-1.0=0.65803736, rnn_1step_CC_maskV_-1.0=0.81856084, rnn_1step_MSE_maskV_-1.0=0.33056331, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53848368, val_rnn_1step_R2_maskV_-1.0=0.37503588, val_rnn_1step_CC_maskV_-1.0=0.66862589, learning_rate=0.001\n", + "Epoch 103/167 - loss=rnn_1step_loss=0.30109668, rnn_1step_R2_maskV_-1.0=0.68819439, rnn_1step_CC_maskV_-1.0=0.83613145, rnn_1step_MSE_maskV_-1.0=0.30109665, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55348611, val_rnn_1step_R2_maskV_-1.0=0.35734928, val_rnn_1step_CC_maskV_-1.0=0.66794026, learning_rate=0.001\n", + "Epoch 120/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27446353, rnn_1step_R2_maskV_-1.0=0.71533054, rnn_1step_CC_maskV_-1.0=0.85207647, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53581452, val_rnn_1step_R2_maskV_-1.0=0.37802392, val_rnn_1step_CC_maskV_-1.0=0.68100327, learning_rate=0.001\n", + "Epoch 137/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.25047326, rnn_1step_R2_maskV_-1.0=0.74062932, rnn_1step_CC_maskV_-1.0=0.8661381, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53470731, val_rnn_1step_R2_maskV_-1.0=0.37965626, val_rnn_1step_CC_maskV_-1.0=0.68787324, learning_rate=0.001\n", + "Epoch 154/167 - loss=rnn_1step_loss=0.228633, rnn_1step_R2_maskV_-1.0=0.76347244, rnn_1step_CC_maskV_-1.0=0.87855041, rnn_1step_MSE_maskV_-1.0=0.22863302, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50019425, val_rnn_1step_R2_maskV_-1.0=0.42021906, val_rnn_1step_CC_maskV_-1.0=0.69941694, learning_rate=0.001\n", + "Epoch 167/167 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.21549831, rnn_1step_R2_maskV_-1.0=0.77624613, rnn_1step_CC_maskV_-1.0=0.88613218, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51280016, val_rnn_1step_R2_maskV_-1.0=0.40624461, val_rnn_1step_CC_maskV_-1.0=0.6932196, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:17:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 19.48s\n", + "\u001b[32m2025-05-30 16:17:30\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:17:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 125 (stopped at 140 epochs).\n", + "\u001b[32m2025-05-30 16:17:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.002308, rnn_1_1step_R2_maskV_-1.0=-0.013630424, rnn_1_1step_CC_maskV_-1.0=0.032719743, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.91792792, val_rnn_1_1step_R2_maskV_-1.0=-0.06014134, val_rnn_1_1step_CC_maskV_-1.0=0.33697641, learning_rate=0.001\n", + "Epoch 16/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.68445545, rnn_1_1step_R2_maskV_-1.0=0.30167323, rnn_1_1step_CC_maskV_-1.0=0.56185687, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.67177755, val_rnn_1_1step_R2_maskV_-1.0=0.22030146, val_rnn_1_1step_CC_maskV_-1.0=0.52196199, learning_rate=0.001\n", + "Epoch 31/141 - loss=rnn_1_1step_loss=0.53291017, rnn_1_1step_R2_maskV_-1.0=0.45245627, rnn_1_1step_CC_maskV_-1.0=0.68335962, rnn_1_1step_MSE_maskV_-1.0=0.53291023, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63596493, val_rnn_1_1step_R2_maskV_-1.0=0.26095879, val_rnn_1_1step_CC_maskV_-1.0=0.57683486, learning_rate=0.001\n", + "Epoch 46/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.45004642, rnn_1_1step_R2_maskV_-1.0=0.53602481, rnn_1_1step_CC_maskV_-1.0=0.74143273, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59928674, val_rnn_1_1step_R2_maskV_-1.0=0.3038063, val_rnn_1_1step_CC_maskV_-1.0=0.61424321, learning_rate=0.001\n", + "Epoch 61/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.37831149, rnn_1_1step_R2_maskV_-1.0=0.60867447, rnn_1_1step_CC_maskV_-1.0=0.78924906, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57794076, val_rnn_1_1step_R2_maskV_-1.0=0.32904905, val_rnn_1_1step_CC_maskV_-1.0=0.64195311, learning_rate=0.001\n", + "Epoch 76/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33566388, rnn_1_1step_R2_maskV_-1.0=0.65218329, rnn_1_1step_CC_maskV_-1.0=0.81518012, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59352654, val_rnn_1_1step_R2_maskV_-1.0=0.31037444, val_rnn_1_1step_CC_maskV_-1.0=0.64374262, learning_rate=0.001\n", + "Epoch 91/141 - loss=rnn_1_1step_loss=0.30923334, rnn_1_1step_R2_maskV_-1.0=0.67941165, rnn_1_1step_CC_maskV_-1.0=0.83126086, rnn_1_1step_MSE_maskV_-1.0=0.30923337, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57763028, val_rnn_1_1step_R2_maskV_-1.0=0.32875893, val_rnn_1_1step_CC_maskV_-1.0=0.65552068, learning_rate=0.001\n", + "Epoch 106/141 - loss=rnn_1_1step_loss=0.29058036, rnn_1_1step_R2_maskV_-1.0=0.69841385, rnn_1_1step_CC_maskV_-1.0=0.84287971, rnn_1_1step_MSE_maskV_-1.0=0.29058033, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54908961, val_rnn_1_1step_R2_maskV_-1.0=0.36204177, val_rnn_1_1step_CC_maskV_-1.0=0.66956496, learning_rate=0.001\n", + "Epoch 121/141 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.27304265, rnn_1_1step_R2_maskV_-1.0=0.71654016, rnn_1_1step_CC_maskV_-1.0=0.85332096, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55310053, val_rnn_1_1step_R2_maskV_-1.0=0.35755667, val_rnn_1_1step_CC_maskV_-1.0=0.6719107, learning_rate=0.001\n", + "Epoch 136/141 - loss=rnn_1_1step_loss=0.25141773, rnn_1_1step_R2_maskV_-1.0=0.73889518, rnn_1_1step_CC_maskV_-1.0=0.86533761, rnn_1_1step_MSE_maskV_-1.0=0.2514177, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.55005449, val_rnn_1_1step_R2_maskV_-1.0=0.36094183, val_rnn_1_1step_CC_maskV_-1.0=0.6766271, learning_rate=0.001\n", + "Epoch 141/141 - loss=rnn_1_1step_loss=0.24873394, rnn_1_1step_R2_maskV_-1.0=0.74218285, rnn_1_1step_CC_maskV_-1.0=0.86733437, rnn_1_1step_MSE_maskV_-1.0=0.24873395, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53792977, val_rnn_1_1step_R2_maskV_-1.0=0.37571126, val_rnn_1_1step_CC_maskV_-1.0=0.68094158, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:17:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 16.84s\n", + "\u001b[32m2025-05-30 16:17:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.48935303)\n", + "\u001b[32m2025-05-30 16:17:48\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.224, R2_maskV_-1.0=0.776, CC_maskV_-1.0=0.884\n", + "\u001b[32m2025-05-30 16:17:48\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.483, R2_maskV_-1.0=0.454, CC_maskV_-1.0=0.712\n", + "\u001b[32m2025-05-30 16:17:48\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:17:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:18:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 172 (stopped at 187 epochs).\n", + "\u001b[32m2025-05-30 16:18:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/188 - loss=1.2865995, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.11216161, MSE_maskV_-1.0=1.2860044, val_loss=0.98617309, val_CC_maskV_-1.0=0.21474802, val_MSE_maskV_-1.0=0.98334217, learning_rate=0.001\n", + "Epoch 20/188 - loss=0.79711276, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45148042, MSE_maskV_-1.0=0.79704624, val_loss=0.84176266, val_CC_maskV_-1.0=0.42689618, val_MSE_maskV_-1.0=0.84000289, learning_rate=0.001\n", + "Epoch 39/188 - loss=0.76108819, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4896262, MSE_maskV_-1.0=0.76116383, val_loss=0.8068071, val_CC_maskV_-1.0=0.46226293, val_MSE_maskV_-1.0=0.80571973, learning_rate=0.001\n", + "Epoch 58/188 - loss=0.74025828, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51007867, MSE_maskV_-1.0=0.74012977, val_loss=0.78955626, val_CC_maskV_-1.0=0.4794336, val_MSE_maskV_-1.0=0.78784877, learning_rate=0.001\n", + "Epoch 77/188 - loss=0.72909737, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52081937, MSE_maskV_-1.0=0.7284748, val_loss=0.77964807, val_CC_maskV_-1.0=0.48911166, val_MSE_maskV_-1.0=0.77754837, learning_rate=0.001\n", + "Epoch 96/188 - loss=0.72151756, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5270713, MSE_maskV_-1.0=0.72155023, val_loss=0.77537388, val_CC_maskV_-1.0=0.49233404, val_MSE_maskV_-1.0=0.77322531, learning_rate=0.001\n", + "Epoch 115/188 - loss=0.71628559, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53217989, MSE_maskV_-1.0=0.71601254, val_loss=0.7730996, val_CC_maskV_-1.0=0.49665388, val_MSE_maskV_-1.0=0.77043533, learning_rate=0.001\n", + "Epoch 134/188 - loss=0.71246511, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53596061, MSE_maskV_-1.0=0.71361047, val_loss=0.76922631, val_CC_maskV_-1.0=0.49911869, val_MSE_maskV_-1.0=0.76627475, learning_rate=0.001\n", + "Epoch 153/188 - loss=0.70828831, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54013407, MSE_maskV_-1.0=0.708731, val_loss=0.76584619, val_CC_maskV_-1.0=0.50296199, val_MSE_maskV_-1.0=0.76273286, learning_rate=0.001\n", + "Epoch 172/188 - loss=0.70488906, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54217142, MSE_maskV_-1.0=0.70582682, val_loss=0.75976896, val_CC_maskV_-1.0=0.50840312, val_MSE_maskV_-1.0=0.7563048, learning_rate=0.001\n", + "Epoch 188/188 - loss=0.70225883, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5446471, MSE_maskV_-1.0=0.7012037, val_loss=0.76244241, val_CC_maskV_-1.0=0.50569981, val_MSE_maskV_-1.0=0.75896949, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:18:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 49.89s\n", + "\u001b[32m2025-05-30 16:18:38\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:19:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 145 (stopped at 160 epochs).\n", + "\u001b[32m2025-05-30 16:19:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/161 - loss=1.1258832, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.12252499, MSE_maskV_-1.0=1.1257606, val_loss=0.97990388, val_CC_maskV_-1.0=0.22065583, val_MSE_maskV_-1.0=0.97649205, learning_rate=0.001\n", + "Epoch 18/161 - loss=0.78629953, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46423668, MSE_maskV_-1.0=0.78634977, val_loss=0.83177304, val_CC_maskV_-1.0=0.43408927, val_MSE_maskV_-1.0=0.83012509, learning_rate=0.001\n", + "Epoch 35/161 - loss=0.75613016, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49392703, MSE_maskV_-1.0=0.75567842, val_loss=0.80487841, val_CC_maskV_-1.0=0.46299201, val_MSE_maskV_-1.0=0.80305946, learning_rate=0.001\n", + "Epoch 52/161 - loss=0.74075878, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50895041, MSE_maskV_-1.0=0.74115598, val_loss=0.79204071, val_CC_maskV_-1.0=0.47632936, val_MSE_maskV_-1.0=0.79036278, learning_rate=0.001\n", + "Epoch 69/161 - loss=0.73009735, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51838279, MSE_maskV_-1.0=0.73057789, val_loss=0.78269339, val_CC_maskV_-1.0=0.48515639, val_MSE_maskV_-1.0=0.78054261, learning_rate=0.001\n", + "Epoch 86/161 - loss=0.72265124, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52597713, MSE_maskV_-1.0=0.72504222, val_loss=0.77492124, val_CC_maskV_-1.0=0.49173468, val_MSE_maskV_-1.0=0.77263677, learning_rate=0.001\n", + "Epoch 103/161 - loss=0.71742421, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53154141, MSE_maskV_-1.0=0.71717089, val_loss=0.76880485, val_CC_maskV_-1.0=0.49786082, val_MSE_maskV_-1.0=0.76672471, learning_rate=0.001\n", + "Epoch 120/161 - loss=0.71258253, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53582251, MSE_maskV_-1.0=0.71221858, val_loss=0.76453602, val_CC_maskV_-1.0=0.50058705, val_MSE_maskV_-1.0=0.76316911, learning_rate=0.001\n", + "Epoch 137/161 - loss=0.70902574, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53928226, MSE_maskV_-1.0=0.70903701, val_loss=0.76540977, val_CC_maskV_-1.0=0.49949074, val_MSE_maskV_-1.0=0.76434642, learning_rate=0.001\n", + "Epoch 154/161 - loss=0.70578301, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54073083, MSE_maskV_-1.0=0.70543742, val_loss=0.76107937, val_CC_maskV_-1.0=0.50447881, val_MSE_maskV_-1.0=0.75897616, learning_rate=0.001\n", + "Epoch 161/161 - loss=0.70418358, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54345638, MSE_maskV_-1.0=0.70414317, val_loss=0.75874168, val_CC_maskV_-1.0=0.50774288, val_MSE_maskV_-1.0=0.75663787, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:19:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 43.58s\n", + "\u001b[32m2025-05-30 16:19:22\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.75786144)\n", + "\u001b[32m2025-05-30 16:19:22\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 817us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:19:22\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.704, R2_maskV_-1.0=0.296, CC_maskV_-1.0=0.545\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 905us/step\n", + "51/51 [==============================] - 0s 815us/step\n", + "84/84 [==============================] - 0s 1ms/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:19:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 3/4 method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16\" (16/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4_DPAD_RTR2_uAKCzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:19:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1948] \u001b[1;30mINFO\u001b[0m Saving results for fold 3 as ..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f3_4.p\n", + "\u001b[32m2025-05-30 16:19:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1381] \u001b[1;30mINFO\u001b[0m Fold 4/4: training samples: 8016, test samples=2670\n", + "\u001b[32m2025-05-30 16:19:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1754] \u001b[1;30mINFO\u001b[0m Running fold 4 (NTrain=8016, NTest=2670)\n", + "\u001b[32m2025-05-30 16:19:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1849] \u001b[1;30mINFO\u001b[0m Signal dimensions: y => (10686, 46), z => (10686, 4), u => None\n", + "\u001b[32m2025-05-30 16:19:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1856] \u001b[1;30mINFO\u001b[0m Method codes to fit: ['DPAD_RTR2_ErSV16', 'DPAD_RTR2_A1HL64U_ErSV16', 'DPAD_RTR2_K1HL64U_ErSV16', 'DPAD_RTR2_Cz1HL64U_ErSV16', 'DPAD_RTR2_Cy1HL64U_ErSV16', 'DPAD_RTR2_uAK1HL64U_ErSV16', 'DPAD_RTR2_ACz1HL64U_ErSV16', 'DPAD_RTR2_ACy1HL64U_ErSV16', 'DPAD_RTR2_KCz1HL64U_ErSV16', 'DPAD_RTR2_KCy1HL64U_ErSV16', 'DPAD_RTR2_CzCy1HL64U_ErSV16', 'DPAD_RTR2_uAKCz1HL64U_ErSV16', 'DPAD_RTR2_uAKCy1HL64U_ErSV16', 'DPAD_RTR2_ACzCy1HL64U_ErSV16', 'DPAD_RTR2_KCzCy1HL64U_ErSV16', 'DPAD_RTR2_uAKCzCy1HL64U_ErSV16']\n", + "\u001b[32m2025-05-30 16:19:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1857] \u001b[1;30mINFO\u001b[0m Nx values to fit: [16]\n", + "\u001b[32m2025-05-30 16:19:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_ErSV16\" (1/16)\n", + "\u001b[32m2025-05-30 16:19:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:19:23\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:19:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:19:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:19:23\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:19:23\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:19:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:19:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 209 (stopped at 224 epochs).\n", + "\u001b[32m2025-05-30 16:19:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/225 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0024899, rnn_1step_R2_maskV_-1.0=-0.0077258088, rnn_1step_CC_maskV_-1.0=0.09133558, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0810214, val_rnn_1step_R2_maskV_-1.0=-0.034184039, val_rnn_1step_CC_maskV_-1.0=0.2163295, learning_rate=0.001\n", + "Epoch 24/225 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.60200638, rnn_1step_R2_maskV_-1.0=0.3907125, rnn_1step_CC_maskV_-1.0=0.63237393, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.68955374, val_rnn_1step_R2_maskV_-1.0=0.33802068, val_rnn_1step_CC_maskV_-1.0=0.60651797, learning_rate=0.001\n", + "Epoch 47/225 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.50659031, rnn_1step_R2_maskV_-1.0=0.48493138, rnn_1step_CC_maskV_-1.0=0.70392698, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54551607, val_rnn_1step_R2_maskV_-1.0=0.4788698, val_rnn_1step_CC_maskV_-1.0=0.70396918, learning_rate=0.001\n", + "Epoch 70/225 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.48055109, rnn_1step_R2_maskV_-1.0=0.51078033, rnn_1step_CC_maskV_-1.0=0.72235924, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52236289, val_rnn_1step_R2_maskV_-1.0=0.50076848, val_rnn_1step_CC_maskV_-1.0=0.72053319, learning_rate=0.001\n", + "Epoch 93/225 - loss=rnn_1step_loss=0.4499791, rnn_1step_R2_maskV_-1.0=0.54197687, rnn_1step_CC_maskV_-1.0=0.74335462, rnn_1step_MSE_maskV_-1.0=0.44997913, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51096791, val_rnn_1step_R2_maskV_-1.0=0.51228786, val_rnn_1step_CC_maskV_-1.0=0.7279712, learning_rate=0.001\n", + "Epoch 116/225 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42585912, rnn_1step_R2_maskV_-1.0=0.56593853, rnn_1step_CC_maskV_-1.0=0.75911665, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.485075, val_rnn_1step_R2_maskV_-1.0=0.53668499, val_rnn_1step_CC_maskV_-1.0=0.7432791, learning_rate=0.001\n", + "Epoch 139/225 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42005754, rnn_1step_R2_maskV_-1.0=0.57117283, rnn_1step_CC_maskV_-1.0=0.76274258, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47781324, val_rnn_1step_R2_maskV_-1.0=0.5434401, val_rnn_1step_CC_maskV_-1.0=0.74746281, learning_rate=0.001\n", + "Epoch 162/225 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41877735, rnn_1step_R2_maskV_-1.0=0.57231414, rnn_1step_CC_maskV_-1.0=0.76352286, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47647274, val_rnn_1step_R2_maskV_-1.0=0.54476452, val_rnn_1step_CC_maskV_-1.0=0.74821562, learning_rate=0.001\n", + "Epoch 185/225 - loss=rnn_1step_loss=0.41777575, rnn_1step_R2_maskV_-1.0=0.57327765, rnn_1step_CC_maskV_-1.0=0.76413906, rnn_1step_MSE_maskV_-1.0=0.41777572, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47580242, val_rnn_1step_R2_maskV_-1.0=0.54539335, val_rnn_1step_CC_maskV_-1.0=0.74857819, learning_rate=0.001\n", + "Epoch 208/225 - loss=rnn_1step_loss=0.41696063, rnn_1step_R2_maskV_-1.0=0.57407331, rnn_1step_CC_maskV_-1.0=0.76464212, rnn_1step_MSE_maskV_-1.0=0.41696066, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47562158, val_rnn_1step_R2_maskV_-1.0=0.54552901, val_rnn_1step_CC_maskV_-1.0=0.7486465, learning_rate=0.001\n", + "Epoch 225/225 - loss=rnn_1step_loss=0.41646108, rnn_1step_R2_maskV_-1.0=0.57455909, rnn_1step_CC_maskV_-1.0=0.76495081, rnn_1step_MSE_maskV_-1.0=0.41646111, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47567508, val_rnn_1step_R2_maskV_-1.0=0.54544413, val_rnn_1step_CC_maskV_-1.0=0.74858302, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:19:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 20.56s\n", + "\u001b[32m2025-05-30 16:19:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:20:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 189 (stopped at 204 epochs).\n", + "\u001b[32m2025-05-30 16:20:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/205 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0051608, rnn_1_1step_R2_maskV_-1.0=-0.010456715, rnn_1_1step_CC_maskV_-1.0=0.028481275, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0851799, val_rnn_1_1step_R2_maskV_-1.0=-0.038321957, val_rnn_1_1step_CC_maskV_-1.0=0.13992107, learning_rate=0.001\n", + "Epoch 22/205 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.64216214, rnn_1_1step_R2_maskV_-1.0=0.34964436, rnn_1_1step_CC_maskV_-1.0=0.60049838, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.73674536, val_rnn_1_1step_R2_maskV_-1.0=0.29167175, val_rnn_1_1step_CC_maskV_-1.0=0.57442617, learning_rate=0.001\n", + "Epoch 43/205 - loss=rnn_1_1step_loss=0.5437997, rnn_1_1step_R2_maskV_-1.0=0.44853151, rnn_1_1step_CC_maskV_-1.0=0.67673349, rnn_1_1step_MSE_maskV_-1.0=0.54379976, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62568325, val_rnn_1_1step_R2_maskV_-1.0=0.39936891, val_rnn_1_1step_CC_maskV_-1.0=0.65081716, learning_rate=0.001\n", + "Epoch 64/205 - loss=rnn_1_1step_loss=0.49369755, rnn_1_1step_R2_maskV_-1.0=0.49782014, rnn_1_1step_CC_maskV_-1.0=0.71313328, rnn_1_1step_MSE_maskV_-1.0=0.49369758, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52410686, val_rnn_1_1step_R2_maskV_-1.0=0.49853417, val_rnn_1_1step_CC_maskV_-1.0=0.7182399, learning_rate=0.001\n", + "Epoch 85/205 - loss=rnn_1_1step_loss=0.46533498, rnn_1_1step_R2_maskV_-1.0=0.52630007, rnn_1_1step_CC_maskV_-1.0=0.73276764, rnn_1_1step_MSE_maskV_-1.0=0.46533495, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50664538, val_rnn_1_1step_R2_maskV_-1.0=0.51479137, val_rnn_1_1step_CC_maskV_-1.0=0.73065132, learning_rate=0.001\n", + "Epoch 106/205 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.43387112, rnn_1_1step_R2_maskV_-1.0=0.55810016, rnn_1_1step_CC_maskV_-1.0=0.75383425, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48961392, val_rnn_1_1step_R2_maskV_-1.0=0.53123754, val_rnn_1_1step_CC_maskV_-1.0=0.74101663, learning_rate=0.001\n", + "Epoch 127/205 - loss=rnn_1_1step_loss=0.42245683, rnn_1_1step_R2_maskV_-1.0=0.56899583, rnn_1_1step_CC_maskV_-1.0=0.76118743, rnn_1_1step_MSE_maskV_-1.0=0.42245686, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47942606, val_rnn_1_1step_R2_maskV_-1.0=0.54159886, val_rnn_1_1step_CC_maskV_-1.0=0.74685317, learning_rate=0.001\n", + "Epoch 148/205 - loss=rnn_1_1step_loss=0.41994667, rnn_1_1step_R2_maskV_-1.0=0.57117981, rnn_1_1step_CC_maskV_-1.0=0.76274633, rnn_1_1step_MSE_maskV_-1.0=0.4199467, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47627166, val_rnn_1_1step_R2_maskV_-1.0=0.54481435, val_rnn_1_1step_CC_maskV_-1.0=0.74849683, learning_rate=0.001\n", + "Epoch 169/205 - loss=rnn_1_1step_loss=0.41850412, rnn_1_1step_R2_maskV_-1.0=0.57247502, rnn_1_1step_CC_maskV_-1.0=0.76363873, rnn_1_1step_MSE_maskV_-1.0=0.41850415, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47460178, val_rnn_1_1step_R2_maskV_-1.0=0.54648042, val_rnn_1_1step_CC_maskV_-1.0=0.74932563, learning_rate=0.001\n", + "Epoch 190/205 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41757563, rnn_1_1step_R2_maskV_-1.0=0.57333213, rnn_1_1step_CC_maskV_-1.0=0.76421356, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47415197, val_rnn_1_1step_R2_maskV_-1.0=0.54693168, val_rnn_1_1step_CC_maskV_-1.0=0.74946356, learning_rate=0.001\n", + "Epoch 205/205 - loss=rnn_1_1step_loss=0.41712299, rnn_1_1step_R2_maskV_-1.0=0.57375801, rnn_1_1step_CC_maskV_-1.0=0.76449364, rnn_1_1step_MSE_maskV_-1.0=0.41712302, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47434044, val_rnn_1_1step_R2_maskV_-1.0=0.54674929, val_rnn_1_1step_CC_maskV_-1.0=0.74927264, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:20:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 19.01s\n", + "\u001b[32m2025-05-30 16:20:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.47415188)\n", + "\u001b[32m2025-05-30 16:20:04\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.362, R2_maskV_-1.0=0.638, CC_maskV_-1.0=0.799\n", + "\u001b[32m2025-05-30 16:20:04\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.461, R2_maskV_-1.0=0.548, CC_maskV_-1.0=0.752\n", + "\u001b[32m2025-05-30 16:20:04\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:20:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:21:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 251 (stopped at 266 epochs).\n", + "\u001b[32m2025-05-30 16:21:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/267 - loss=8.9016933, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.026102973, MSE_maskV_-1.0=8.8812399, val_loss=1.8784571, val_CC_maskV_-1.0=0.040254578, val_MSE_maskV_-1.0=1.8647572, learning_rate=0.001\n", + "Epoch 28/267 - loss=0.87408519, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35562956, MSE_maskV_-1.0=0.87377524, val_loss=0.95111734, val_CC_maskV_-1.0=0.32637981, val_MSE_maskV_-1.0=0.94632387, learning_rate=0.001\n", + "Epoch 55/267 - loss=0.82475227, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42037594, MSE_maskV_-1.0=0.82601309, val_loss=0.88962251, val_CC_maskV_-1.0=0.40112558, val_MSE_maskV_-1.0=0.88585901, learning_rate=0.001\n", + "Epoch 82/267 - loss=0.7968998, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45322636, MSE_maskV_-1.0=0.79726011, val_loss=0.86351138, val_CC_maskV_-1.0=0.43011293, val_MSE_maskV_-1.0=0.85991323, learning_rate=0.001\n", + "Epoch 109/267 - loss=0.7816419, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46934736, MSE_maskV_-1.0=0.78140312, val_loss=0.84638214, val_CC_maskV_-1.0=0.44705239, val_MSE_maskV_-1.0=0.8432048, learning_rate=0.001\n", + "Epoch 136/267 - loss=0.77102464, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48025191, MSE_maskV_-1.0=0.77105242, val_loss=0.82663429, val_CC_maskV_-1.0=0.46560246, val_MSE_maskV_-1.0=0.82381094, learning_rate=0.001\n", + "Epoch 163/267 - loss=0.76271862, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48894262, MSE_maskV_-1.0=0.7622323, val_loss=0.82688338, val_CC_maskV_-1.0=0.46595842, val_MSE_maskV_-1.0=0.82417917, learning_rate=0.001\n", + "Epoch 190/267 - loss=0.75648814, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49465433, MSE_maskV_-1.0=0.75606912, val_loss=0.82070327, val_CC_maskV_-1.0=0.47201699, val_MSE_maskV_-1.0=0.8178643, learning_rate=0.001\n", + "Epoch 217/267 - loss=0.75240117, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49845943, MSE_maskV_-1.0=0.75307757, val_loss=0.81075799, val_CC_maskV_-1.0=0.47748518, val_MSE_maskV_-1.0=0.80816269, learning_rate=0.001\n", + "Epoch 244/267 - loss=0.74954188, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50080717, MSE_maskV_-1.0=0.74939638, val_loss=0.80725557, val_CC_maskV_-1.0=0.48334104, val_MSE_maskV_-1.0=0.80464411, learning_rate=0.001\n", + "Epoch 267/267 - loss=0.74716824, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50252759, MSE_maskV_-1.0=0.7466526, val_loss=0.81015527, val_CC_maskV_-1.0=0.48219338, val_MSE_maskV_-1.0=0.80745804, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:21:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 65.17s\n", + "\u001b[32m2025-05-30 16:21:09\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:22:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 213 (stopped at 228 epochs).\n", + "\u001b[32m2025-05-30 16:22:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/229 - loss=13.337318, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.020138219, MSE_maskV_-1.0=13.305305, val_loss=2.2254984, val_CC_maskV_-1.0=0.028504748, val_MSE_maskV_-1.0=2.2009585, learning_rate=0.001\n", + "Epoch 24/229 - loss=0.88353962, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34222841, MSE_maskV_-1.0=0.88315737, val_loss=0.94830978, val_CC_maskV_-1.0=0.32734245, val_MSE_maskV_-1.0=0.94356519, learning_rate=0.001\n", + "Epoch 47/229 - loss=0.83433944, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40755987, MSE_maskV_-1.0=0.83536381, val_loss=0.8990199, val_CC_maskV_-1.0=0.39107811, val_MSE_maskV_-1.0=0.89497983, learning_rate=0.001\n", + "Epoch 70/229 - loss=0.80763179, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44059587, MSE_maskV_-1.0=0.80723912, val_loss=0.87103075, val_CC_maskV_-1.0=0.4199295, val_MSE_maskV_-1.0=0.86751449, learning_rate=0.001\n", + "Epoch 93/229 - loss=0.78994864, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46025559, MSE_maskV_-1.0=0.78927672, val_loss=0.85394388, val_CC_maskV_-1.0=0.43843341, val_MSE_maskV_-1.0=0.8507427, learning_rate=0.001\n", + "Epoch 116/229 - loss=0.77787066, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4727239, MSE_maskV_-1.0=0.77772409, val_loss=0.84258127, val_CC_maskV_-1.0=0.45040455, val_MSE_maskV_-1.0=0.8394115, learning_rate=0.001\n", + "Epoch 139/229 - loss=0.76865518, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48298785, MSE_maskV_-1.0=0.76858318, val_loss=0.83232963, val_CC_maskV_-1.0=0.45992041, val_MSE_maskV_-1.0=0.82946348, learning_rate=0.001\n", + "Epoch 162/229 - loss=0.762546, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48837027, MSE_maskV_-1.0=0.76258677, val_loss=0.82600754, val_CC_maskV_-1.0=0.46269533, val_MSE_maskV_-1.0=0.82311159, learning_rate=0.001\n", + "Epoch 185/229 - loss=0.75758845, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49287072, MSE_maskV_-1.0=0.75697106, val_loss=0.81755871, val_CC_maskV_-1.0=0.4733007, val_MSE_maskV_-1.0=0.81509137, learning_rate=0.001\n", + "Epoch 208/229 - loss=0.75360209, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49685457, MSE_maskV_-1.0=0.7531209, val_loss=0.81372887, val_CC_maskV_-1.0=0.47758707, val_MSE_maskV_-1.0=0.81123829, learning_rate=0.001\n", + "Epoch 229/229 - loss=0.75149643, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49891719, MSE_maskV_-1.0=0.75097609, val_loss=0.81740618, val_CC_maskV_-1.0=0.47465941, val_MSE_maskV_-1.0=0.8148247, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:22:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 56.52s\n", + "\u001b[32m2025-05-30 16:22:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.80313605)\n", + "\u001b[32m2025-05-30 16:22:06\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 757us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:22:06\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.746, R2_maskV_-1.0=0.254, CC_maskV_-1.0=0.505\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 790us/step\n", + "51/51 [==============================] - 0s 749us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:22:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_ErSV16\" (1/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:22:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_A1HL64U_ErSV16\" (2/16)\n", + "\u001b[32m2025-05-30 16:22:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_A1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:22:07\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:22:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:22:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:22:07\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:22:07\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:22:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:22:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 167 (stopped at 182 epochs).\n", + "\u001b[32m2025-05-30 16:22:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/183 - loss=rnn_1step_loss=0.99948788, rnn_1step_R2_maskV_-1.0=-0.0048149861, rnn_1step_CC_maskV_-1.0=0.14353526, rnn_1step_MSE_maskV_-1.0=0.99948782, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0809841, val_rnn_1step_R2_maskV_-1.0=-0.034019157, val_rnn_1step_CC_maskV_-1.0=0.1940947, learning_rate=0.001\n", + "Epoch 20/183 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.69639254, rnn_1step_R2_maskV_-1.0=0.29519451, rnn_1step_CC_maskV_-1.0=0.55668408, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.79950124, val_rnn_1step_R2_maskV_-1.0=0.23456062, val_rnn_1step_CC_maskV_-1.0=0.52042907, learning_rate=0.001\n", + "Epoch 39/183 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.52327925, rnn_1step_R2_maskV_-1.0=0.46690416, rnn_1step_CC_maskV_-1.0=0.6918205, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62140518, val_rnn_1step_R2_maskV_-1.0=0.40204099, val_rnn_1step_CC_maskV_-1.0=0.65291619, learning_rate=0.001\n", + "Epoch 58/183 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.43700624, rnn_1step_R2_maskV_-1.0=0.55301344, rnn_1step_CC_maskV_-1.0=0.7517401, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52623272, val_rnn_1step_R2_maskV_-1.0=0.49528259, val_rnn_1step_CC_maskV_-1.0=0.71700066, learning_rate=0.001\n", + "Epoch 77/183 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.40982154, rnn_1step_R2_maskV_-1.0=0.58008957, rnn_1step_CC_maskV_-1.0=0.76964992, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51583678, val_rnn_1step_R2_maskV_-1.0=0.50524014, val_rnn_1step_CC_maskV_-1.0=0.7232548, learning_rate=0.001\n", + "Epoch 96/183 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3909038, rnn_1step_R2_maskV_-1.0=0.59894377, rnn_1step_CC_maskV_-1.0=0.78190517, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50005168, val_rnn_1step_R2_maskV_-1.0=0.52079809, val_rnn_1step_CC_maskV_-1.0=0.73359698, learning_rate=0.001\n", + "Epoch 115/183 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38290012, rnn_1step_R2_maskV_-1.0=0.60707176, rnn_1step_CC_maskV_-1.0=0.78738397, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50273234, val_rnn_1step_R2_maskV_-1.0=0.51886553, val_rnn_1step_CC_maskV_-1.0=0.73141307, learning_rate=0.001\n", + "Epoch 134/183 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35983679, rnn_1step_R2_maskV_-1.0=0.63083911, rnn_1step_CC_maskV_-1.0=0.80140513, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48788342, val_rnn_1step_R2_maskV_-1.0=0.53369898, val_rnn_1step_CC_maskV_-1.0=0.74710965, learning_rate=0.001\n", + "Epoch 153/183 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34125772, rnn_1step_R2_maskV_-1.0=0.65023977, rnn_1step_CC_maskV_-1.0=0.81282151, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47930202, val_rnn_1step_R2_maskV_-1.0=0.54213297, val_rnn_1step_CC_maskV_-1.0=0.74775887, learning_rate=0.001\n", + "Epoch 172/183 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3353523, rnn_1step_R2_maskV_-1.0=0.65590113, rnn_1step_CC_maskV_-1.0=0.81647849, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47466242, val_rnn_1step_R2_maskV_-1.0=0.5472312, val_rnn_1step_CC_maskV_-1.0=0.75073719, learning_rate=0.001\n", + "Epoch 183/183 - loss=rnn_1step_loss=0.32943574, rnn_1step_R2_maskV_-1.0=0.66259527, rnn_1step_CC_maskV_-1.0=0.82065576, rnn_1step_MSE_maskV_-1.0=0.32943577, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4735533, val_rnn_1step_R2_maskV_-1.0=0.54774344, val_rnn_1step_CC_maskV_-1.0=0.74973965, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:22:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 21.15s\n", + "\u001b[32m2025-05-30 16:22:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:22:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 143 (stopped at 158 epochs).\n", + "\u001b[32m2025-05-30 16:22:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/159 - loss=rnn_1_1step_loss=1.0061928, rnn_1_1step_R2_maskV_-1.0=-0.011378713, rnn_1_1step_CC_maskV_-1.0=0.0059998278, rnn_1_1step_MSE_maskV_-1.0=1.0061929, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0869826, val_rnn_1_1step_R2_maskV_-1.0=-0.039982095, val_rnn_1_1step_CC_maskV_-1.0=0.11354756, learning_rate=0.001\n", + "Epoch 17/159 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.74661905, rnn_1_1step_R2_maskV_-1.0=0.24760659, rnn_1_1step_CC_maskV_-1.0=0.51301122, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.84856319, val_rnn_1_1step_R2_maskV_-1.0=0.18518889, val_rnn_1_1step_CC_maskV_-1.0=0.49371332, learning_rate=0.001\n", + "Epoch 33/159 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.58231211, rnn_1_1step_R2_maskV_-1.0=0.4103407, rnn_1_1step_CC_maskV_-1.0=0.64960814, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.69600564, val_rnn_1_1step_R2_maskV_-1.0=0.32883802, val_rnn_1_1step_CC_maskV_-1.0=0.60973895, learning_rate=0.001\n", + "Epoch 49/159 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.50856256, rnn_1_1step_R2_maskV_-1.0=0.48440778, rnn_1_1step_CC_maskV_-1.0=0.70250553, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62243718, val_rnn_1_1step_R2_maskV_-1.0=0.40190583, val_rnn_1_1step_CC_maskV_-1.0=0.65383482, learning_rate=0.001\n", + "Epoch 65/159 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.45960748, rnn_1_1step_R2_maskV_-1.0=0.53334165, rnn_1_1step_CC_maskV_-1.0=0.73647124, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.58323079, val_rnn_1_1step_R2_maskV_-1.0=0.44138777, val_rnn_1_1step_CC_maskV_-1.0=0.67928261, learning_rate=0.001\n", + "Epoch 81/159 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42817926, rnn_1_1step_R2_maskV_-1.0=0.56423515, rnn_1_1step_CC_maskV_-1.0=0.75762755, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56468916, val_rnn_1_1step_R2_maskV_-1.0=0.45842052, val_rnn_1_1step_CC_maskV_-1.0=0.69103515, learning_rate=0.001\n", + "Epoch 97/159 - loss=rnn_1_1step_loss=0.40325871, rnn_1_1step_R2_maskV_-1.0=0.58900595, rnn_1_1step_CC_maskV_-1.0=0.7740556, rnn_1_1step_MSE_maskV_-1.0=0.40325868, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56082809, val_rnn_1_1step_R2_maskV_-1.0=0.46127164, val_rnn_1_1step_CC_maskV_-1.0=0.69843847, learning_rate=0.001\n", + "Epoch 113/159 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.37737027, rnn_1_1step_R2_maskV_-1.0=0.61537445, rnn_1_1step_CC_maskV_-1.0=0.79035485, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51355863, val_rnn_1_1step_R2_maskV_-1.0=0.50652385, val_rnn_1_1step_CC_maskV_-1.0=0.7260325, learning_rate=0.001\n", + "Epoch 129/159 - loss=rnn_1_1step_loss=0.37355748, rnn_1_1step_R2_maskV_-1.0=0.61806184, rnn_1_1step_CC_maskV_-1.0=0.79311401, rnn_1_1step_MSE_maskV_-1.0=0.37355751, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50763029, val_rnn_1_1step_R2_maskV_-1.0=0.51212877, val_rnn_1_1step_CC_maskV_-1.0=0.72762042, learning_rate=0.001\n", + "Epoch 145/159 - loss=rnn_1_1step_loss=0.34783319, rnn_1_1step_R2_maskV_-1.0=0.64445114, rnn_1_1step_CC_maskV_-1.0=0.80985469, rnn_1_1step_MSE_maskV_-1.0=0.34783322, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48807886, val_rnn_1_1step_R2_maskV_-1.0=0.53128028, val_rnn_1_1step_CC_maskV_-1.0=0.73921078, learning_rate=0.001\n", + "Epoch 159/159 - loss=rnn_1_1step_loss=0.33460531, rnn_1_1step_R2_maskV_-1.0=0.65742511, rnn_1_1step_CC_maskV_-1.0=0.81716168, rnn_1_1step_MSE_maskV_-1.0=0.33460534, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48948327, val_rnn_1_1step_R2_maskV_-1.0=0.52977979, val_rnn_1_1step_CC_maskV_-1.0=0.7466656, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:22:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 18.68s\n", + "\u001b[32m2025-05-30 16:22:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.45088741)\n", + "\u001b[32m2025-05-30 16:22:49\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.302, R2_maskV_-1.0=0.698, CC_maskV_-1.0=0.836\n", + "\u001b[32m2025-05-30 16:22:49\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.425, R2_maskV_-1.0=0.586, CC_maskV_-1.0=0.774\n", + "\u001b[32m2025-05-30 16:22:49\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:22:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:23:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 102 (stopped at 117 epochs).\n", + "\u001b[32m2025-05-30 16:23:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/118 - loss=3.1569479, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.035915319, MSE_maskV_-1.0=3.1527057, val_loss=1.34975, val_CC_maskV_-1.0=0.075982675, val_MSE_maskV_-1.0=1.3391327, learning_rate=0.001\n", + "Epoch 13/118 - loss=0.82230139, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42219907, MSE_maskV_-1.0=0.82158345, val_loss=0.87023449, val_CC_maskV_-1.0=0.41459423, val_MSE_maskV_-1.0=0.86582994, learning_rate=0.001\n", + "Epoch 25/118 - loss=0.77724886, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47297636, MSE_maskV_-1.0=0.77677327, val_loss=0.82662421, val_CC_maskV_-1.0=0.4607352, val_MSE_maskV_-1.0=0.82246155, learning_rate=0.001\n", + "Epoch 37/118 - loss=0.76180553, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48862675, MSE_maskV_-1.0=0.76168442, val_loss=0.80911392, val_CC_maskV_-1.0=0.47734338, val_MSE_maskV_-1.0=0.80510074, learning_rate=0.001\n", + "Epoch 49/118 - loss=0.75389701, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49672407, MSE_maskV_-1.0=0.75346577, val_loss=0.79841846, val_CC_maskV_-1.0=0.48710784, val_MSE_maskV_-1.0=0.79448819, learning_rate=0.001\n", + "Epoch 61/118 - loss=0.74843788, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50138432, MSE_maskV_-1.0=0.74843812, val_loss=0.79594123, val_CC_maskV_-1.0=0.48899192, val_MSE_maskV_-1.0=0.79196513, learning_rate=0.001\n", + "Epoch 73/118 - loss=0.74530101, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50457948, MSE_maskV_-1.0=0.74516958, val_loss=0.79454935, val_CC_maskV_-1.0=0.49035999, val_MSE_maskV_-1.0=0.79058152, learning_rate=0.001\n", + "Epoch 85/118 - loss=0.74307632, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50646526, MSE_maskV_-1.0=0.74340099, val_loss=0.78839165, val_CC_maskV_-1.0=0.49544233, val_MSE_maskV_-1.0=0.78453177, learning_rate=0.001\n", + "Epoch 97/118 - loss=0.74099201, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50914776, MSE_maskV_-1.0=0.74096829, val_loss=0.78877401, val_CC_maskV_-1.0=0.49540415, val_MSE_maskV_-1.0=0.78483784, learning_rate=0.001\n", + "Epoch 109/118 - loss=0.73980123, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50945687, MSE_maskV_-1.0=0.73960459, val_loss=0.78562665, val_CC_maskV_-1.0=0.49856117, val_MSE_maskV_-1.0=0.7817629, learning_rate=0.001\n", + "Epoch 118/118 - loss=0.73895186, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51126349, MSE_maskV_-1.0=0.73863381, val_loss=0.78470314, val_CC_maskV_-1.0=0.49931952, val_MSE_maskV_-1.0=0.78081042, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:23:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 29.85s\n", + "\u001b[32m2025-05-30 16:23:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:23:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 102 (stopped at 117 epochs).\n", + "\u001b[32m2025-05-30 16:23:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/118 - loss=2.444052, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.049107909, MSE_maskV_-1.0=2.4417944, val_loss=1.316846, val_CC_maskV_-1.0=0.087082379, val_MSE_maskV_-1.0=1.3078134, learning_rate=0.001\n", + "Epoch 13/118 - loss=0.81855834, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42569321, MSE_maskV_-1.0=0.81788504, val_loss=0.86877632, val_CC_maskV_-1.0=0.41451797, val_MSE_maskV_-1.0=0.86511678, learning_rate=0.001\n", + "Epoch 25/118 - loss=0.77827644, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47159886, MSE_maskV_-1.0=0.77781534, val_loss=0.82920408, val_CC_maskV_-1.0=0.45769161, val_MSE_maskV_-1.0=0.82535708, learning_rate=0.001\n", + "Epoch 37/118 - loss=0.76283085, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48741895, MSE_maskV_-1.0=0.76270312, val_loss=0.81059968, val_CC_maskV_-1.0=0.47594002, val_MSE_maskV_-1.0=0.80675972, learning_rate=0.001\n", + "Epoch 49/118 - loss=0.75463486, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49601528, MSE_maskV_-1.0=0.75420135, val_loss=0.79965848, val_CC_maskV_-1.0=0.48600566, val_MSE_maskV_-1.0=0.79583567, learning_rate=0.001\n", + "Epoch 61/118 - loss=0.74884677, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50093645, MSE_maskV_-1.0=0.74886078, val_loss=0.79650748, val_CC_maskV_-1.0=0.48852098, val_MSE_maskV_-1.0=0.79260898, learning_rate=0.001\n", + "Epoch 73/118 - loss=0.74553353, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50437182, MSE_maskV_-1.0=0.74537778, val_loss=0.79491848, val_CC_maskV_-1.0=0.49001786, val_MSE_maskV_-1.0=0.79100084, learning_rate=0.001\n", + "Epoch 85/118 - loss=0.74319118, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50631112, MSE_maskV_-1.0=0.74353075, val_loss=0.78854752, val_CC_maskV_-1.0=0.49531585, val_MSE_maskV_-1.0=0.78472644, learning_rate=0.001\n", + "Epoch 97/118 - loss=0.74101502, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50914592, MSE_maskV_-1.0=0.74099326, val_loss=0.78881729, val_CC_maskV_-1.0=0.49535087, val_MSE_maskV_-1.0=0.78490996, learning_rate=0.001\n", + "Epoch 109/118 - loss=0.73979419, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50943166, MSE_maskV_-1.0=0.73959899, val_loss=0.78561038, val_CC_maskV_-1.0=0.49857196, val_MSE_maskV_-1.0=0.78176862, learning_rate=0.001\n", + "Epoch 118/118 - loss=0.73895383, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51123959, MSE_maskV_-1.0=0.73863643, val_loss=0.78475183, val_CC_maskV_-1.0=0.49924704, val_MSE_maskV_-1.0=0.7808724, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:23:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 29.33s\n", + "\u001b[32m2025-05-30 16:23:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.78461981)\n", + "\u001b[32m2025-05-30 16:23:48\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 787us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:23:48\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.739, R2_maskV_-1.0=0.262, CC_maskV_-1.0=0.512\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 753us/step\n", + "51/51 [==============================] - 0s 828us/step\n", + "84/84 [==============================] - 0s 738us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:23:49\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_A1HL64U_ErSV16\" (2/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_A1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:23:49\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_K1HL64U_ErSV16\" (3/16)\n", + "\u001b[32m2025-05-30 16:23:49\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_K1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:23:49\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:23:49\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:23:49\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:23:49\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:23:49\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:23:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:24:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 105 (stopped at 120 epochs).\n", + "\u001b[32m2025-05-30 16:24:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/121 - loss=rnn_1step_loss=1.0051426, rnn_1step_R2_maskV_-1.0=-0.010542627, rnn_1step_CC_maskV_-1.0=0.11262186, rnn_1step_MSE_maskV_-1.0=1.0051425, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.088838, val_rnn_1step_R2_maskV_-1.0=-0.041822389, val_rnn_1step_CC_maskV_-1.0=0.30210015, learning_rate=0.001\n", + "Epoch 14/121 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.7219224, rnn_1step_R2_maskV_-1.0=0.26923433, rnn_1step_CC_maskV_-1.0=0.53118187, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.81488758, val_rnn_1step_R2_maskV_-1.0=0.21452634, val_rnn_1step_CC_maskV_-1.0=0.5080415, learning_rate=0.001\n", + "Epoch 27/121 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.58114582, rnn_1step_R2_maskV_-1.0=0.41030842, rnn_1step_CC_maskV_-1.0=0.64974076, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.70050305, val_rnn_1step_R2_maskV_-1.0=0.32296717, val_rnn_1step_CC_maskV_-1.0=0.60090131, learning_rate=0.001\n", + "Epoch 40/121 - loss=rnn_1step_loss=0.47158024, rnn_1step_R2_maskV_-1.0=0.52008516, rnn_1step_CC_maskV_-1.0=0.72806835, rnn_1step_MSE_maskV_-1.0=0.47158021, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58735847, val_rnn_1step_R2_maskV_-1.0=0.4353025, val_rnn_1step_CC_maskV_-1.0=0.67663777, learning_rate=0.001\n", + "Epoch 53/121 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.39754501, rnn_1step_R2_maskV_-1.0=0.59505916, rnn_1step_CC_maskV_-1.0=0.77755463, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49302164, val_rnn_1step_R2_maskV_-1.0=0.52745974, val_rnn_1step_CC_maskV_-1.0=0.73640752, learning_rate=0.001\n", + "Epoch 66/121 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34228602, rnn_1step_R2_maskV_-1.0=0.65176344, rnn_1step_CC_maskV_-1.0=0.81243902, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45351294, val_rnn_1step_R2_maskV_-1.0=0.56569886, val_rnn_1step_CC_maskV_-1.0=0.76098359, learning_rate=0.001\n", + "Epoch 79/121 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29163194, rnn_1step_R2_maskV_-1.0=0.70396781, rnn_1step_CC_maskV_-1.0=0.84295762, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.43971649, val_rnn_1step_R2_maskV_-1.0=0.57903111, val_rnn_1step_CC_maskV_-1.0=0.76982462, learning_rate=0.001\n", + "Epoch 92/121 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27193952, rnn_1step_R2_maskV_-1.0=0.72302783, rnn_1step_CC_maskV_-1.0=0.85468674, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45189944, val_rnn_1step_R2_maskV_-1.0=0.56889069, val_rnn_1step_CC_maskV_-1.0=0.76401657, learning_rate=0.001\n", + "Epoch 105/121 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.23864824, rnn_1step_R2_maskV_-1.0=0.75767523, rnn_1step_CC_maskV_-1.0=0.8736794, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42238545, val_rnn_1step_R2_maskV_-1.0=0.59567499, val_rnn_1step_CC_maskV_-1.0=0.78029913, learning_rate=0.001\n", + "Epoch 118/121 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.22644152, rnn_1step_R2_maskV_-1.0=0.76989049, rnn_1step_CC_maskV_-1.0=0.88057959, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42325044, val_rnn_1step_R2_maskV_-1.0=0.59511024, val_rnn_1step_CC_maskV_-1.0=0.77978987, learning_rate=0.001\n", + "Epoch 121/121 - loss=rnn_1step_loss=0.22417045, rnn_1step_R2_maskV_-1.0=0.77208376, rnn_1step_CC_maskV_-1.0=0.88183761, rnn_1step_MSE_maskV_-1.0=0.22417046, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42332673, val_rnn_1step_R2_maskV_-1.0=0.59496748, val_rnn_1step_CC_maskV_-1.0=0.77969867, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:24:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 13.05s\n", + "\u001b[32m2025-05-30 16:24:02\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:24:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 114 (stopped at 129 epochs).\n", + "\u001b[32m2025-05-30 16:24:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/130 - loss=rnn_1_1step_loss=1.0052218, rnn_1_1step_R2_maskV_-1.0=-0.010620113, rnn_1_1step_CC_maskV_-1.0=0.12225828, rnn_1_1step_MSE_maskV_-1.0=1.005222, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0893158, val_rnn_1_1step_R2_maskV_-1.0=-0.042260736, val_rnn_1_1step_CC_maskV_-1.0=0.30332407, learning_rate=0.001\n", + "Epoch 14/130 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.79486912, rnn_1_1step_R2_maskV_-1.0=0.19986708, rnn_1_1step_CC_maskV_-1.0=0.46505517, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.87567568, val_rnn_1_1step_R2_maskV_-1.0=0.15969037, val_rnn_1_1step_CC_maskV_-1.0=0.4655517, learning_rate=0.001\n", + "Epoch 27/130 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.55292529, rnn_1_1step_R2_maskV_-1.0=0.43816471, rnn_1_1step_CC_maskV_-1.0=0.66997099, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.66687101, val_rnn_1_1step_R2_maskV_-1.0=0.36223453, val_rnn_1_1step_CC_maskV_-1.0=0.62184048, learning_rate=0.001\n", + "Epoch 40/130 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.4624103, rnn_1_1step_R2_maskV_-1.0=0.52902043, rnn_1_1step_CC_maskV_-1.0=0.73421681, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54975915, val_rnn_1_1step_R2_maskV_-1.0=0.47676495, val_rnn_1_1step_CC_maskV_-1.0=0.70049626, learning_rate=0.001\n", + "Epoch 53/130 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39848682, rnn_1_1step_R2_maskV_-1.0=0.59364974, rnn_1_1step_CC_maskV_-1.0=0.77655256, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48595729, val_rnn_1_1step_R2_maskV_-1.0=0.53709942, val_rnn_1_1step_CC_maskV_-1.0=0.7415576, learning_rate=0.001\n", + "Epoch 66/130 - loss=rnn_1_1step_loss=0.34979597, rnn_1_1step_R2_maskV_-1.0=0.6431936, rnn_1_1step_CC_maskV_-1.0=0.80711925, rnn_1_1step_MSE_maskV_-1.0=0.34979594, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.44502416, val_rnn_1_1step_R2_maskV_-1.0=0.57579207, val_rnn_1_1step_CC_maskV_-1.0=0.76582915, learning_rate=0.001\n", + "Epoch 79/130 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.29884672, rnn_1_1step_R2_maskV_-1.0=0.69618523, rnn_1_1step_CC_maskV_-1.0=0.83822024, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.42939171, val_rnn_1_1step_R2_maskV_-1.0=0.58988559, val_rnn_1_1step_CC_maskV_-1.0=0.77560216, learning_rate=0.001\n", + "Epoch 92/130 - loss=rnn_1_1step_loss=0.25025329, rnn_1_1step_R2_maskV_-1.0=0.74616909, rnn_1_1step_CC_maskV_-1.0=0.86683768, rnn_1_1step_MSE_maskV_-1.0=0.25025326, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41744193, val_rnn_1_1step_R2_maskV_-1.0=0.59948659, val_rnn_1_1step_CC_maskV_-1.0=0.78308582, learning_rate=0.001\n", + "Epoch 105/130 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.23518091, rnn_1_1step_R2_maskV_-1.0=0.76086074, rnn_1_1step_CC_maskV_-1.0=0.87541556, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.42736611, val_rnn_1_1step_R2_maskV_-1.0=0.58889252, val_rnn_1_1step_CC_maskV_-1.0=0.77691466, learning_rate=0.001\n", + "Epoch 118/130 - loss=rnn_1_1step_loss=0.22297259, rnn_1_1step_R2_maskV_-1.0=0.77410406, rnn_1_1step_CC_maskV_-1.0=0.88239372, rnn_1_1step_MSE_maskV_-1.0=0.2229726, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41446838, val_rnn_1_1step_R2_maskV_-1.0=0.60234904, val_rnn_1_1step_CC_maskV_-1.0=0.7856828, learning_rate=0.001\n", + "Epoch 130/130 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.21783727, rnn_1_1step_R2_maskV_-1.0=0.77887022, rnn_1_1step_CC_maskV_-1.0=0.88576496, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41764021, val_rnn_1_1step_R2_maskV_-1.0=0.59960628, val_rnn_1_1step_CC_maskV_-1.0=0.78278112, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:24:16\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 13.89s\n", + "\u001b[32m2025-05-30 16:24:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.41000345)\n", + "\u001b[32m2025-05-30 16:24:18\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.199, R2_maskV_-1.0=0.801, CC_maskV_-1.0=0.895\n", + "\u001b[32m2025-05-30 16:24:18\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.375, R2_maskV_-1.0=0.633, CC_maskV_-1.0=0.803\n", + "\u001b[32m2025-05-30 16:24:18\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:24:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:25:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 290 (stopped at 305 epochs).\n", + "\u001b[32m2025-05-30 16:25:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/306 - loss=1.9943539, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.047443073, MSE_maskV_-1.0=1.9926507, val_loss=1.1330379, val_CC_maskV_-1.0=0.083468497, val_MSE_maskV_-1.0=1.1280123, learning_rate=0.001\n", + "Epoch 32/306 - loss=0.88560426, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34390864, MSE_maskV_-1.0=0.88575745, val_loss=0.95274997, val_CC_maskV_-1.0=0.3217887, val_MSE_maskV_-1.0=0.94908261, learning_rate=0.001\n", + "Epoch 63/306 - loss=0.86375165, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3742153, MSE_maskV_-1.0=0.86309361, val_loss=0.93157411, val_CC_maskV_-1.0=0.35020858, val_MSE_maskV_-1.0=0.92821348, learning_rate=0.001\n", + "Epoch 94/306 - loss=0.85035223, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39103603, MSE_maskV_-1.0=0.85040915, val_loss=0.91176987, val_CC_maskV_-1.0=0.37508294, val_MSE_maskV_-1.0=0.90878612, learning_rate=0.001\n", + "Epoch 125/306 - loss=0.84072441, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40388203, MSE_maskV_-1.0=0.84035283, val_loss=0.89954549, val_CC_maskV_-1.0=0.38980761, val_MSE_maskV_-1.0=0.89676249, learning_rate=0.001\n", + "Epoch 156/306 - loss=0.83298373, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41320089, MSE_maskV_-1.0=0.83341378, val_loss=0.89221817, val_CC_maskV_-1.0=0.39837426, val_MSE_maskV_-1.0=0.88948208, learning_rate=0.001\n", + "Epoch 187/306 - loss=0.82676244, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.419956, MSE_maskV_-1.0=0.82552361, val_loss=0.88500983, val_CC_maskV_-1.0=0.40700501, val_MSE_maskV_-1.0=0.88219696, learning_rate=0.001\n", + "Epoch 218/306 - loss=0.82215428, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42594633, MSE_maskV_-1.0=0.82182086, val_loss=0.8810699, val_CC_maskV_-1.0=0.41025954, val_MSE_maskV_-1.0=0.8785615, learning_rate=0.001\n", + "Epoch 249/306 - loss=0.81769353, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43074602, MSE_maskV_-1.0=0.81708485, val_loss=0.875916, val_CC_maskV_-1.0=0.41587526, val_MSE_maskV_-1.0=0.87320673, learning_rate=0.001\n", + "Epoch 280/306 - loss=0.81424493, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43434018, MSE_maskV_-1.0=0.81443369, val_loss=0.87026244, val_CC_maskV_-1.0=0.42169893, val_MSE_maskV_-1.0=0.86764318, learning_rate=0.001\n", + "Epoch 306/306 - loss=0.81154466, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43750691, MSE_maskV_-1.0=0.81173593, val_loss=0.86823314, val_CC_maskV_-1.0=0.42303309, val_MSE_maskV_-1.0=0.86558568, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:25:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 74.06s\n", + "\u001b[32m2025-05-30 16:25:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:26:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 290 (stopped at 305 epochs).\n", + "\u001b[32m2025-05-30 16:26:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/306 - loss=1.6516063, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.040302474, MSE_maskV_-1.0=1.6509714, val_loss=1.1091503, val_CC_maskV_-1.0=0.091014415, val_MSE_maskV_-1.0=1.1026291, learning_rate=0.001\n", + "Epoch 32/306 - loss=0.88733751, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34039858, MSE_maskV_-1.0=0.88749146, val_loss=0.95446002, val_CC_maskV_-1.0=0.31865868, val_MSE_maskV_-1.0=0.95074236, learning_rate=0.001\n", + "Epoch 63/306 - loss=0.86599123, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37053677, MSE_maskV_-1.0=0.8653273, val_loss=0.93390077, val_CC_maskV_-1.0=0.34656158, val_MSE_maskV_-1.0=0.93063158, learning_rate=0.001\n", + "Epoch 94/306 - loss=0.85238719, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38800037, MSE_maskV_-1.0=0.85243642, val_loss=0.91398036, val_CC_maskV_-1.0=0.37195987, val_MSE_maskV_-1.0=0.9110871, learning_rate=0.001\n", + "Epoch 125/306 - loss=0.84250438, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4013958, MSE_maskV_-1.0=0.84213346, val_loss=0.90153682, val_CC_maskV_-1.0=0.38713294, val_MSE_maskV_-1.0=0.89884704, learning_rate=0.001\n", + "Epoch 156/306 - loss=0.83450967, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41119137, MSE_maskV_-1.0=0.83494145, val_loss=0.89395189, val_CC_maskV_-1.0=0.3961167, val_MSE_maskV_-1.0=0.89130646, learning_rate=0.001\n", + "Epoch 187/306 - loss=0.82808793, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4182348, MSE_maskV_-1.0=0.82685083, val_loss=0.88666046, val_CC_maskV_-1.0=0.40486458, val_MSE_maskV_-1.0=0.88394403, learning_rate=0.001\n", + "Epoch 218/306 - loss=0.8233338, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42447591, MSE_maskV_-1.0=0.82299358, val_loss=0.88251358, val_CC_maskV_-1.0=0.4084442, val_MSE_maskV_-1.0=0.88009733, learning_rate=0.001\n", + "Epoch 249/306 - loss=0.81873208, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42946598, MSE_maskV_-1.0=0.81812918, val_loss=0.87736505, val_CC_maskV_-1.0=0.41405088, val_MSE_maskV_-1.0=0.87474418, learning_rate=0.001\n", + "Epoch 280/306 - loss=0.81517369, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43321419, MSE_maskV_-1.0=0.81537223, val_loss=0.87151277, val_CC_maskV_-1.0=0.4200981, val_MSE_maskV_-1.0=0.86898124, learning_rate=0.001\n", + "Epoch 306/306 - loss=0.812388, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.43648991, MSE_maskV_-1.0=0.81258428, val_loss=0.86932528, val_CC_maskV_-1.0=0.42163438, val_MSE_maskV_-1.0=0.86676252, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:26:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 82.54s\n", + "\u001b[32m2025-05-30 16:26:54\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.86756688)\n", + "\u001b[32m2025-05-30 16:26:54\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 744us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:26:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.813, R2_maskV_-1.0=0.186, CC_maskV_-1.0=0.435\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 916us/step\n", + "51/51 [==============================] - 0s 844us/step\n", + "84/84 [==============================] - 0s 738us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:26:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_K1HL64U_ErSV16\" (3/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_K1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:26:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_Cz1HL64U_ErSV16\" (4/16)\n", + "\u001b[32m2025-05-30 16:26:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_Cz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:26:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:26:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:26:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:26:56\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:26:56\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:26:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:27:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 188 (stopped at 203 epochs).\n", + "\u001b[32m2025-05-30 16:27:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/204 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0045763, rnn_1step_R2_maskV_-1.0=-0.009963315, rnn_1step_CC_maskV_-1.0=0.17106956, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0885154, val_rnn_1step_R2_maskV_-1.0=-0.041522115, val_rnn_1step_CC_maskV_-1.0=0.2612994, learning_rate=0.001\n", + "Epoch 22/204 - loss=rnn_1step_loss=0.66845244, rnn_1step_R2_maskV_-1.0=0.32080907, rnn_1step_CC_maskV_-1.0=0.57804328, rnn_1step_MSE_maskV_-1.0=0.6684525, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.77578044, val_rnn_1step_R2_maskV_-1.0=0.26078725, val_rnn_1step_CC_maskV_-1.0=0.53906941, learning_rate=0.001\n", + "Epoch 43/204 - loss=rnn_1step_loss=0.4713687, rnn_1step_R2_maskV_-1.0=0.51988649, rnn_1step_CC_maskV_-1.0=0.72827852, rnn_1step_MSE_maskV_-1.0=0.47136867, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54622334, val_rnn_1step_R2_maskV_-1.0=0.47833198, val_rnn_1step_CC_maskV_-1.0=0.70403647, learning_rate=0.001\n", + "Epoch 64/204 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3969312, rnn_1step_R2_maskV_-1.0=0.59438783, rnn_1step_CC_maskV_-1.0=0.7780388, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45208183, val_rnn_1step_R2_maskV_-1.0=0.56713319, val_rnn_1step_CC_maskV_-1.0=0.76445991, learning_rate=0.001\n", + "Epoch 85/204 - loss=rnn_1step_loss=0.36857036, rnn_1step_R2_maskV_-1.0=0.62322837, rnn_1step_CC_maskV_-1.0=0.79609203, rnn_1step_MSE_maskV_-1.0=0.36857039, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42533484, val_rnn_1step_R2_maskV_-1.0=0.59221852, val_rnn_1step_CC_maskV_-1.0=0.78025997, learning_rate=0.001\n", + "Epoch 106/204 - loss=rnn_1step_loss=0.3583602, rnn_1step_R2_maskV_-1.0=0.63343352, rnn_1step_CC_maskV_-1.0=0.80240571, rnn_1step_MSE_maskV_-1.0=0.35836023, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.41105628, val_rnn_1step_R2_maskV_-1.0=0.60574967, val_rnn_1step_CC_maskV_-1.0=0.78819829, learning_rate=0.001\n", + "Epoch 127/204 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35250661, rnn_1step_R2_maskV_-1.0=0.63920563, rnn_1step_CC_maskV_-1.0=0.80602437, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.40712103, val_rnn_1step_R2_maskV_-1.0=0.60960406, val_rnn_1step_CC_maskV_-1.0=0.79008096, learning_rate=0.001\n", + "Epoch 148/204 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3482796, rnn_1step_R2_maskV_-1.0=0.64338362, rnn_1step_CC_maskV_-1.0=0.80862558, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.40529001, val_rnn_1step_R2_maskV_-1.0=0.6113764, val_rnn_1step_CC_maskV_-1.0=0.79090029, learning_rate=0.001\n", + "Epoch 169/204 - loss=rnn_1step_loss=0.34464666, rnn_1step_R2_maskV_-1.0=0.64702338, rnn_1step_CC_maskV_-1.0=0.81084776, rnn_1step_MSE_maskV_-1.0=0.34464663, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.40341675, val_rnn_1step_R2_maskV_-1.0=0.61308491, val_rnn_1step_CC_maskV_-1.0=0.79173779, learning_rate=0.001\n", + "Epoch 190/204 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34150109, rnn_1step_R2_maskV_-1.0=0.65022147, rnn_1step_CC_maskV_-1.0=0.81273943, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.40294304, val_rnn_1step_R2_maskV_-1.0=0.61351252, val_rnn_1step_CC_maskV_-1.0=0.79190522, learning_rate=0.001\n", + "Epoch 204/204 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33956957, rnn_1step_R2_maskV_-1.0=0.65214342, rnn_1step_CC_maskV_-1.0=0.81390655, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.40256324, val_rnn_1step_R2_maskV_-1.0=0.61382663, val_rnn_1step_CC_maskV_-1.0=0.79200095, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:27:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 20.89s\n", + "\u001b[32m2025-05-30 16:27:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:27:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 265 (stopped at 280 epochs).\n", + "\u001b[32m2025-05-30 16:27:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/281 - loss=rnn_1_1step_loss=1.0055056, rnn_1_1step_R2_maskV_-1.0=-0.010914236, rnn_1_1step_CC_maskV_-1.0=0.059623428, rnn_1_1step_MSE_maskV_-1.0=1.0055054, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.089362, val_rnn_1_1step_R2_maskV_-1.0=-0.042270899, val_rnn_1_1step_CC_maskV_-1.0=0.20113057, learning_rate=0.001\n", + "Epoch 30/281 - loss=rnn_1_1step_loss=0.52824706, rnn_1_1step_R2_maskV_-1.0=0.46258289, rnn_1_1step_CC_maskV_-1.0=0.68791503, rnn_1_1step_MSE_maskV_-1.0=0.528247, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61312079, val_rnn_1_1step_R2_maskV_-1.0=0.41169387, val_rnn_1_1step_CC_maskV_-1.0=0.66104084, learning_rate=0.001\n", + "Epoch 59/281 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42545399, rnn_1_1step_R2_maskV_-1.0=0.5654431, rnn_1_1step_CC_maskV_-1.0=0.75923097, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4633801, val_rnn_1_1step_R2_maskV_-1.0=0.5545336, val_rnn_1_1step_CC_maskV_-1.0=0.75692183, learning_rate=0.001\n", + "Epoch 88/281 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38758969, rnn_1_1step_R2_maskV_-1.0=0.60382885, rnn_1_1step_CC_maskV_-1.0=0.78382111, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4408296, val_rnn_1_1step_R2_maskV_-1.0=0.57498723, val_rnn_1_1step_CC_maskV_-1.0=0.77054042, learning_rate=0.001\n", + "Epoch 117/281 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.3574264, rnn_1_1step_R2_maskV_-1.0=0.63452476, rnn_1_1step_CC_maskV_-1.0=0.80285561, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.42308751, val_rnn_1_1step_R2_maskV_-1.0=0.59295261, val_rnn_1_1step_CC_maskV_-1.0=0.78048462, learning_rate=0.001\n", + "Epoch 146/281 - loss=rnn_1_1step_loss=0.34653139, rnn_1_1step_R2_maskV_-1.0=0.64537311, rnn_1_1step_CC_maskV_-1.0=0.80971652, rnn_1_1step_MSE_maskV_-1.0=0.34653142, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41184759, val_rnn_1_1step_R2_maskV_-1.0=0.60461122, val_rnn_1_1step_CC_maskV_-1.0=0.78733367, learning_rate=0.001\n", + "Epoch 175/281 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33881536, rnn_1_1step_R2_maskV_-1.0=0.65290827, rnn_1_1step_CC_maskV_-1.0=0.81446481, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.40864363, val_rnn_1_1step_R2_maskV_-1.0=0.60792959, val_rnn_1_1step_CC_maskV_-1.0=0.78900617, learning_rate=0.001\n", + "Epoch 204/281 - loss=rnn_1_1step_loss=0.33222085, rnn_1_1step_R2_maskV_-1.0=0.65937275, rnn_1_1step_CC_maskV_-1.0=0.81846082, rnn_1_1step_MSE_maskV_-1.0=0.33222088, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.40644011, val_rnn_1_1step_R2_maskV_-1.0=0.61011791, val_rnn_1_1step_CC_maskV_-1.0=0.79012054, learning_rate=0.001\n", + "Epoch 233/281 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.3264192, rnn_1_1step_R2_maskV_-1.0=0.66511321, rnn_1_1step_CC_maskV_-1.0=0.8219744, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.40589848, val_rnn_1_1step_R2_maskV_-1.0=0.61076456, val_rnn_1_1step_CC_maskV_-1.0=0.79012918, learning_rate=0.001\n", + "Epoch 262/281 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32135135, rnn_1_1step_R2_maskV_-1.0=0.67001987, rnn_1_1step_CC_maskV_-1.0=0.82508671, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.40617266, val_rnn_1_1step_R2_maskV_-1.0=0.61052346, val_rnn_1_1step_CC_maskV_-1.0=0.78984076, learning_rate=0.001\n", + "Epoch 281/281 - loss=rnn_1_1step_loss=0.31867364, rnn_1_1step_R2_maskV_-1.0=0.67275167, rnn_1_1step_CC_maskV_-1.0=0.82669139, rnn_1_1step_MSE_maskV_-1.0=0.31867367, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.40339115, val_rnn_1_1step_R2_maskV_-1.0=0.61302841, val_rnn_1_1step_CC_maskV_-1.0=0.7911942, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:27:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 27.84s\n", + "\u001b[32m2025-05-30 16:27:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.40203127)\n", + "\u001b[32m2025-05-30 16:27:46\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.297, R2_maskV_-1.0=0.703, CC_maskV_-1.0=0.838\n", + "\u001b[32m2025-05-30 16:27:46\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.384, R2_maskV_-1.0=0.623, CC_maskV_-1.0=0.799\n", + "\u001b[32m2025-05-30 16:27:46\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:27:46\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:28:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 188 (stopped at 203 epochs).\n", + "\u001b[32m2025-05-30 16:28:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/204 - loss=6.452425, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.019219236, MSE_maskV_-1.0=6.4392371, val_loss=1.7504117, val_CC_maskV_-1.0=0.022381358, val_MSE_maskV_-1.0=1.7399825, learning_rate=0.001\n", + "Epoch 22/204 - loss=0.83273315, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40939817, MSE_maskV_-1.0=0.8325578, val_loss=0.88810074, val_CC_maskV_-1.0=0.39614585, val_MSE_maskV_-1.0=0.88523626, learning_rate=0.001\n", + "Epoch 43/204 - loss=0.77714103, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47138473, MSE_maskV_-1.0=0.77630043, val_loss=0.84285402, val_CC_maskV_-1.0=0.44816634, val_MSE_maskV_-1.0=0.83982557, learning_rate=0.001\n", + "Epoch 64/204 - loss=0.75486964, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49575514, MSE_maskV_-1.0=0.75518829, val_loss=0.82309431, val_CC_maskV_-1.0=0.4695442, val_MSE_maskV_-1.0=0.81996858, learning_rate=0.001\n", + "Epoch 85/204 - loss=0.74385709, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5061574, MSE_maskV_-1.0=0.74423361, val_loss=0.80912763, val_CC_maskV_-1.0=0.48483324, val_MSE_maskV_-1.0=0.80600035, learning_rate=0.001\n", + "Epoch 106/204 - loss=0.73660046, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51306504, MSE_maskV_-1.0=0.73641849, val_loss=0.80619651, val_CC_maskV_-1.0=0.48760271, val_MSE_maskV_-1.0=0.80288112, learning_rate=0.001\n", + "Epoch 127/204 - loss=0.73058623, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51896906, MSE_maskV_-1.0=0.73037195, val_loss=0.79915041, val_CC_maskV_-1.0=0.49414277, val_MSE_maskV_-1.0=0.79576749, learning_rate=0.001\n", + "Epoch 148/204 - loss=0.72725976, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52181983, MSE_maskV_-1.0=0.72660208, val_loss=0.79657781, val_CC_maskV_-1.0=0.49543458, val_MSE_maskV_-1.0=0.79328072, learning_rate=0.001\n", + "Epoch 169/204 - loss=0.72445869, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52475387, MSE_maskV_-1.0=0.72504109, val_loss=0.78698713, val_CC_maskV_-1.0=0.50445199, val_MSE_maskV_-1.0=0.78363907, learning_rate=0.001\n", + "Epoch 190/204 - loss=0.72113305, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52773106, MSE_maskV_-1.0=0.7207045, val_loss=0.79058546, val_CC_maskV_-1.0=0.50245672, val_MSE_maskV_-1.0=0.7870748, learning_rate=0.001\n", + "Epoch 204/204 - loss=0.71965253, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52907872, MSE_maskV_-1.0=0.71987891, val_loss=0.79429781, val_CC_maskV_-1.0=0.49945879, val_MSE_maskV_-1.0=0.79078031, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:28:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 49.99s\n", + "\u001b[32m2025-05-30 16:28:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:29:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 188 (stopped at 203 epochs).\n", + "\u001b[32m2025-05-30 16:29:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/204 - loss=7.1732116, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.02243668, MSE_maskV_-1.0=7.1582632, val_loss=1.7508783, val_CC_maskV_-1.0=0.032035075, val_MSE_maskV_-1.0=1.7372987, learning_rate=0.001\n", + "Epoch 22/204 - loss=0.82833838, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41498604, MSE_maskV_-1.0=0.82806081, val_loss=0.88881695, val_CC_maskV_-1.0=0.39865345, val_MSE_maskV_-1.0=0.88501561, learning_rate=0.001\n", + "Epoch 43/204 - loss=0.77712888, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47135302, MSE_maskV_-1.0=0.77627921, val_loss=0.84615493, val_CC_maskV_-1.0=0.44610894, val_MSE_maskV_-1.0=0.84235668, learning_rate=0.001\n", + "Epoch 64/204 - loss=0.75580323, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49481657, MSE_maskV_-1.0=0.75610876, val_loss=0.8263858, val_CC_maskV_-1.0=0.46717978, val_MSE_maskV_-1.0=0.8226856, learning_rate=0.001\n", + "Epoch 85/204 - loss=0.7449668, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50497544, MSE_maskV_-1.0=0.74533641, val_loss=0.81194508, val_CC_maskV_-1.0=0.4826045, val_MSE_maskV_-1.0=0.80836928, learning_rate=0.001\n", + "Epoch 106/204 - loss=0.73757869, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51200193, MSE_maskV_-1.0=0.7374261, val_loss=0.80771434, val_CC_maskV_-1.0=0.48648942, val_MSE_maskV_-1.0=0.8040517, learning_rate=0.001\n", + "Epoch 127/204 - loss=0.73132735, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5182206, MSE_maskV_-1.0=0.73112208, val_loss=0.80114806, val_CC_maskV_-1.0=0.49260512, val_MSE_maskV_-1.0=0.79748625, learning_rate=0.001\n", + "Epoch 148/204 - loss=0.72782427, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52124345, MSE_maskV_-1.0=0.72716981, val_loss=0.79813468, val_CC_maskV_-1.0=0.49405423, val_MSE_maskV_-1.0=0.79461896, learning_rate=0.001\n", + "Epoch 169/204 - loss=0.72497165, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5242666, MSE_maskV_-1.0=0.72555989, val_loss=0.78810018, val_CC_maskV_-1.0=0.5035367, val_MSE_maskV_-1.0=0.7845788, learning_rate=0.001\n", + "Epoch 190/204 - loss=0.72151405, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52738959, MSE_maskV_-1.0=0.72107965, val_loss=0.79122925, val_CC_maskV_-1.0=0.50191951, val_MSE_maskV_-1.0=0.78758359, learning_rate=0.001\n", + "Epoch 204/204 - loss=0.71993226, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52886868, MSE_maskV_-1.0=0.72015291, val_loss=0.79488921, val_CC_maskV_-1.0=0.49893689, val_MSE_maskV_-1.0=0.79125863, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:29:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 50.16s\n", + "\u001b[32m2025-05-30 16:29:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.78297228)\n", + "\u001b[32m2025-05-30 16:29:26\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 735us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:29:27\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.719, R2_maskV_-1.0=0.279, CC_maskV_-1.0=0.53\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 719us/step\n", + "51/51 [==============================] - 0s 704us/step\n", + "84/84 [==============================] - 0s 739us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:29:27\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_Cz1HL64U_ErSV16\" (4/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_Cz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:29:27\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_Cy1HL64U_ErSV16\" (5/16)\n", + "\u001b[32m2025-05-30 16:29:27\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_Cy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:29:27\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:29:27\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:29:28\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:29:28\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:29:28\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:29:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:29:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 316 (stopped at 331 epochs).\n", + "\u001b[32m2025-05-30 16:29:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/332 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0038172, rnn_1step_R2_maskV_-1.0=-0.009129867, rnn_1step_CC_maskV_-1.0=0.052853286, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0836867, val_rnn_1step_R2_maskV_-1.0=-0.036799312, val_rnn_1step_CC_maskV_-1.0=0.1516861, learning_rate=0.001\n", + "Epoch 35/332 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.53637284, rnn_1step_R2_maskV_-1.0=0.45661011, rnn_1step_CC_maskV_-1.0=0.68283838, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.59027642, val_rnn_1step_R2_maskV_-1.0=0.43553084, val_rnn_1step_CC_maskV_-1.0=0.67431593, learning_rate=0.001\n", + "Epoch 69/332 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.49474299, rnn_1step_R2_maskV_-1.0=0.49679312, rnn_1step_CC_maskV_-1.0=0.71234149, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52186984, val_rnn_1step_R2_maskV_-1.0=0.5005815, val_rnn_1step_CC_maskV_-1.0=0.72084576, learning_rate=0.001\n", + "Epoch 103/332 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.47151354, rnn_1step_R2_maskV_-1.0=0.52007103, rnn_1step_CC_maskV_-1.0=0.72840351, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5055359, val_rnn_1step_R2_maskV_-1.0=0.51556134, val_rnn_1step_CC_maskV_-1.0=0.73123205, learning_rate=0.001\n", + "Epoch 137/332 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.43641567, rnn_1step_R2_maskV_-1.0=0.55552661, rnn_1step_CC_maskV_-1.0=0.75213939, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49453822, val_rnn_1step_R2_maskV_-1.0=0.5255242, val_rnn_1step_CC_maskV_-1.0=0.73782402, learning_rate=0.001\n", + "Epoch 171/332 - loss=rnn_1step_loss=0.41925731, rnn_1step_R2_maskV_-1.0=0.57235575, rnn_1step_CC_maskV_-1.0=0.76336801, rnn_1step_MSE_maskV_-1.0=0.41925728, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48981869, val_rnn_1step_R2_maskV_-1.0=0.53107905, val_rnn_1step_CC_maskV_-1.0=0.74054796, learning_rate=0.001\n", + "Epoch 205/332 - loss=rnn_1step_loss=0.4169805, rnn_1step_R2_maskV_-1.0=0.57447386, rnn_1step_CC_maskV_-1.0=0.76474065, rnn_1step_MSE_maskV_-1.0=0.41698048, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48297366, val_rnn_1step_R2_maskV_-1.0=0.53812528, val_rnn_1step_CC_maskV_-1.0=0.74448973, learning_rate=0.001\n", + "Epoch 239/332 - loss=rnn_1step_loss=0.41674009, rnn_1step_R2_maskV_-1.0=0.57449138, rnn_1step_CC_maskV_-1.0=0.76483536, rnn_1step_MSE_maskV_-1.0=0.41674012, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47949174, val_rnn_1step_R2_maskV_-1.0=0.54151928, val_rnn_1step_CC_maskV_-1.0=0.74636638, learning_rate=0.001\n", + "Epoch 273/332 - loss=rnn_1step_loss=0.41652402, rnn_1step_R2_maskV_-1.0=0.57457322, rnn_1step_CC_maskV_-1.0=0.76494402, rnn_1step_MSE_maskV_-1.0=0.41652396, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47815546, val_rnn_1step_R2_maskV_-1.0=0.54279512, val_rnn_1step_CC_maskV_-1.0=0.74702799, learning_rate=0.001\n", + "Epoch 307/332 - loss=rnn_1step_loss=0.41631922, rnn_1step_R2_maskV_-1.0=0.57470632, rnn_1step_CC_maskV_-1.0=0.76506233, rnn_1step_MSE_maskV_-1.0=0.41631919, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47784153, val_rnn_1step_R2_maskV_-1.0=0.54306442, val_rnn_1step_CC_maskV_-1.0=0.74711263, learning_rate=0.001\n", + "Epoch 332/332 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41614366, rnn_1step_R2_maskV_-1.0=0.57485205, rnn_1step_CC_maskV_-1.0=0.76517183, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47785482, val_rnn_1step_R2_maskV_-1.0=0.54302126, val_rnn_1step_CC_maskV_-1.0=0.74704695, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:29:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 29.12s\n", + "\u001b[32m2025-05-30 16:29:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:30:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 274 (stopped at 289 epochs).\n", + "\u001b[32m2025-05-30 16:30:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/290 - loss=rnn_1_1step_loss=1.0038496, rnn_1_1step_R2_maskV_-1.0=-0.0092162825, rnn_1_1step_CC_maskV_-1.0=0.058246084, rnn_1_1step_MSE_maskV_-1.0=1.0038497, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0849022, val_rnn_1_1step_R2_maskV_-1.0=-0.038186044, val_rnn_1_1step_CC_maskV_-1.0=0.14203043, learning_rate=0.001\n", + "Epoch 30/290 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.60493857, rnn_1_1step_R2_maskV_-1.0=0.38676363, rnn_1_1step_CC_maskV_-1.0=0.63041544, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.71286148, val_rnn_1_1step_R2_maskV_-1.0=0.31934035, val_rnn_1_1step_CC_maskV_-1.0=0.59105557, learning_rate=0.001\n", + "Epoch 59/290 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.52087682, rnn_1_1step_R2_maskV_-1.0=0.47180152, rnn_1_1step_CC_maskV_-1.0=0.69377816, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57347083, val_rnn_1_1step_R2_maskV_-1.0=0.4528347, val_rnn_1_1step_CC_maskV_-1.0=0.6857838, learning_rate=0.001\n", + "Epoch 88/290 - loss=rnn_1_1step_loss=0.47062162, rnn_1_1step_R2_maskV_-1.0=0.5210256, rnn_1_1step_CC_maskV_-1.0=0.72912133, rnn_1_1step_MSE_maskV_-1.0=0.47062168, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51250821, val_rnn_1_1step_R2_maskV_-1.0=0.51086867, val_rnn_1_1step_CC_maskV_-1.0=0.72622412, learning_rate=0.001\n", + "Epoch 117/290 - loss=rnn_1_1step_loss=0.43206194, rnn_1_1step_R2_maskV_-1.0=0.56007314, rnn_1_1step_CC_maskV_-1.0=0.75503135, rnn_1_1step_MSE_maskV_-1.0=0.43206197, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49169841, val_rnn_1_1step_R2_maskV_-1.0=0.53043926, val_rnn_1_1step_CC_maskV_-1.0=0.73906827, learning_rate=0.001\n", + "Epoch 146/290 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42278492, rnn_1_1step_R2_maskV_-1.0=0.56870997, rnn_1_1step_CC_maskV_-1.0=0.76093554, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48092616, val_rnn_1_1step_R2_maskV_-1.0=0.54030615, val_rnn_1_1step_CC_maskV_-1.0=0.74529916, learning_rate=0.001\n", + "Epoch 175/290 - loss=rnn_1_1step_loss=0.4204123, rnn_1_1step_R2_maskV_-1.0=0.57082999, rnn_1_1step_CC_maskV_-1.0=0.76242614, rnn_1_1step_MSE_maskV_-1.0=0.42041233, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4781436, val_rnn_1_1step_R2_maskV_-1.0=0.54300976, val_rnn_1_1step_CC_maskV_-1.0=0.74687976, learning_rate=0.001\n", + "Epoch 204/290 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41874418, rnn_1_1step_R2_maskV_-1.0=0.57241422, rnn_1_1step_CC_maskV_-1.0=0.76347846, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47665882, val_rnn_1_1step_R2_maskV_-1.0=0.54440922, val_rnn_1_1step_CC_maskV_-1.0=0.74768615, learning_rate=0.001\n", + "Epoch 233/290 - loss=rnn_1_1step_loss=0.41742361, rnn_1_1step_R2_maskV_-1.0=0.57369775, rnn_1_1step_CC_maskV_-1.0=0.76431066, rnn_1_1step_MSE_maskV_-1.0=0.41742364, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47610378, val_rnn_1_1step_R2_maskV_-1.0=0.54487908, val_rnn_1_1step_CC_maskV_-1.0=0.74795157, learning_rate=0.001\n", + "Epoch 262/290 - loss=rnn_1_1step_loss=0.41640308, rnn_1_1step_R2_maskV_-1.0=0.57469267, rnn_1_1step_CC_maskV_-1.0=0.76495767, rnn_1_1step_MSE_maskV_-1.0=0.41640311, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47604024, val_rnn_1_1step_R2_maskV_-1.0=0.54486585, val_rnn_1_1step_CC_maskV_-1.0=0.74794209, learning_rate=0.001\n", + "Epoch 290/290 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.41576698, rnn_1_1step_R2_maskV_-1.0=0.57530379, rnn_1_1step_CC_maskV_-1.0=0.7654075, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47645363, val_rnn_1_1step_R2_maskV_-1.0=0.54444021, val_rnn_1_1step_CC_maskV_-1.0=0.74777132, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:30:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 29.94s\n", + "\u001b[32m2025-05-30 16:30:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.47599259)\n", + "\u001b[32m2025-05-30 16:30:28\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.361, R2_maskV_-1.0=0.639, CC_maskV_-1.0=0.8\n", + "\u001b[32m2025-05-30 16:30:28\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.466, R2_maskV_-1.0=0.544, CC_maskV_-1.0=0.75\n", + "\u001b[32m2025-05-30 16:30:28\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:30:28\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:31:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 119 (stopped at 134 epochs).\n", + "\u001b[32m2025-05-30 16:31:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/135 - loss=5.0610991, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.015452269, MSE_maskV_-1.0=5.0505133, val_loss=1.3546027, val_CC_maskV_-1.0=0.029962007, val_MSE_maskV_-1.0=1.3450114, learning_rate=0.001\n", + "Epoch 15/135 - loss=0.8734805, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.35636276, MSE_maskV_-1.0=0.87380344, val_loss=0.95452136, val_CC_maskV_-1.0=0.31505477, val_MSE_maskV_-1.0=0.95018333, learning_rate=0.001\n", + "Epoch 29/135 - loss=0.78163821, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46677709, MSE_maskV_-1.0=0.78174049, val_loss=0.85365123, val_CC_maskV_-1.0=0.43401483, val_MSE_maskV_-1.0=0.85022449, learning_rate=0.001\n", + "Epoch 43/135 - loss=0.74187529, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50608283, MSE_maskV_-1.0=0.74113262, val_loss=0.81550562, val_CC_maskV_-1.0=0.47073686, val_MSE_maskV_-1.0=0.81274462, learning_rate=0.001\n", + "Epoch 57/135 - loss=0.7170701, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53112566, MSE_maskV_-1.0=0.71680963, val_loss=0.77657861, val_CC_maskV_-1.0=0.50220025, val_MSE_maskV_-1.0=0.77432805, learning_rate=0.001\n", + "Epoch 71/135 - loss=0.70374089, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54284143, MSE_maskV_-1.0=0.70364529, val_loss=0.77592629, val_CC_maskV_-1.0=0.50572944, val_MSE_maskV_-1.0=0.77405989, learning_rate=0.001\n", + "Epoch 85/135 - loss=0.69567513, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55017889, MSE_maskV_-1.0=0.69588113, val_loss=0.76533139, val_CC_maskV_-1.0=0.51227713, val_MSE_maskV_-1.0=0.7639659, learning_rate=0.001\n", + "Epoch 99/135 - loss=0.68864363, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55668771, MSE_maskV_-1.0=0.6885497, val_loss=0.77309126, val_CC_maskV_-1.0=0.50938541, val_MSE_maskV_-1.0=0.77125734, learning_rate=0.001\n", + "Epoch 113/135 - loss=0.6847828, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56049365, MSE_maskV_-1.0=0.68504941, val_loss=0.77544481, val_CC_maskV_-1.0=0.5112173, val_MSE_maskV_-1.0=0.77342606, learning_rate=0.001\n", + "Epoch 127/135 - loss=0.6799171, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56446475, MSE_maskV_-1.0=0.67987967, val_loss=0.75840366, val_CC_maskV_-1.0=0.52000874, val_MSE_maskV_-1.0=0.75694841, learning_rate=0.001\n", + "Epoch 135/135 - loss=0.67901248, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56548178, MSE_maskV_-1.0=0.6791743, val_loss=0.75372827, val_CC_maskV_-1.0=0.52283549, val_MSE_maskV_-1.0=0.75218809, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:31:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 35.90s\n", + "\u001b[32m2025-05-30 16:31:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:31:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 125 (stopped at 140 epochs).\n", + "\u001b[32m2025-05-30 16:31:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/141 - loss=5.3065639, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.0094169853, MSE_maskV_-1.0=5.2960277, val_loss=1.4427142, val_CC_maskV_-1.0=0.014036581, val_MSE_maskV_-1.0=1.4325386, learning_rate=0.001\n", + "Epoch 16/141 - loss=0.88061196, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3472828, MSE_maskV_-1.0=0.88071066, val_loss=0.95736724, val_CC_maskV_-1.0=0.30993596, val_MSE_maskV_-1.0=0.95301694, learning_rate=0.001\n", + "Epoch 31/141 - loss=0.78749752, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46093136, MSE_maskV_-1.0=0.78719789, val_loss=0.86998653, val_CC_maskV_-1.0=0.41849768, val_MSE_maskV_-1.0=0.86664486, learning_rate=0.001\n", + "Epoch 46/141 - loss=0.73911452, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50997919, MSE_maskV_-1.0=0.73940992, val_loss=0.81769711, val_CC_maskV_-1.0=0.47178277, val_MSE_maskV_-1.0=0.81434965, learning_rate=0.001\n", + "Epoch 61/141 - loss=0.71660459, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53095287, MSE_maskV_-1.0=0.71669513, val_loss=0.79891878, val_CC_maskV_-1.0=0.48880053, val_MSE_maskV_-1.0=0.79606843, learning_rate=0.001\n", + "Epoch 76/141 - loss=0.70495212, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54159999, MSE_maskV_-1.0=0.70539433, val_loss=0.76879764, val_CC_maskV_-1.0=0.51100701, val_MSE_maskV_-1.0=0.76635885, learning_rate=0.001\n", + "Epoch 91/141 - loss=0.69321203, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5525679, MSE_maskV_-1.0=0.69316649, val_loss=0.75583851, val_CC_maskV_-1.0=0.51982814, val_MSE_maskV_-1.0=0.75348723, learning_rate=0.001\n", + "Epoch 106/141 - loss=0.6876353, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55744237, MSE_maskV_-1.0=0.68752921, val_loss=0.76023901, val_CC_maskV_-1.0=0.51998156, val_MSE_maskV_-1.0=0.75788361, learning_rate=0.001\n", + "Epoch 121/141 - loss=0.68284094, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56163716, MSE_maskV_-1.0=0.68346137, val_loss=0.74596691, val_CC_maskV_-1.0=0.52882683, val_MSE_maskV_-1.0=0.74392313, learning_rate=0.001\n", + "Epoch 136/141 - loss=0.67784685, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56616813, MSE_maskV_-1.0=0.67779976, val_loss=0.74007308, val_CC_maskV_-1.0=0.53251272, val_MSE_maskV_-1.0=0.73800302, learning_rate=0.001\n", + "Epoch 141/141 - loss=0.67734981, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56705844, MSE_maskV_-1.0=0.67724311, val_loss=0.74139756, val_CC_maskV_-1.0=0.53099614, val_MSE_maskV_-1.0=0.73943192, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:31:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 38.11s\n", + "\u001b[32m2025-05-30 16:31:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.73503542)\n", + "\u001b[32m2025-05-30 16:31:42\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 864us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:31:42\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.669, R2_maskV_-1.0=0.332, CC_maskV_-1.0=0.576\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 939us/step\n", + "51/51 [==============================] - 0s 894us/step\n", + "84/84 [==============================] - 0s 852us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:31:43\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_Cy1HL64U_ErSV16\" (5/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_Cy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:31:43\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_uAK1HL64U_ErSV16\" (6/16)\n", + "\u001b[32m2025-05-30 16:31:43\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAK1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:31:43\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:31:43\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:31:44\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:31:44\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:31:44\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:31:44\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:31:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 61 (stopped at 76 epochs).\n", + "\u001b[32m2025-05-30 16:31:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/77 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0054737, rnn_1step_R2_maskV_-1.0=-0.010885227, rnn_1step_CC_maskV_-1.0=0.066233695, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0893401, val_rnn_1step_R2_maskV_-1.0=-0.042267382, val_rnn_1step_CC_maskV_-1.0=0.21636035, learning_rate=0.001\n", + "Epoch 9/77 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.92212039, rnn_1step_R2_maskV_-1.0=0.072544083, rnn_1step_CC_maskV_-1.0=0.34258056, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.99693871, val_rnn_1step_R2_maskV_-1.0=0.044556439, val_rnn_1step_CC_maskV_-1.0=0.31970373, learning_rate=0.001\n", + "Epoch 17/77 - loss=rnn_1step_loss=0.68227452, rnn_1step_R2_maskV_-1.0=0.31016868, rnn_1step_CC_maskV_-1.0=0.56816626, rnn_1step_MSE_maskV_-1.0=0.68227446, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.78431773, val_rnn_1step_R2_maskV_-1.0=0.24440134, val_rnn_1step_CC_maskV_-1.0=0.53757638, learning_rate=0.001\n", + "Epoch 25/77 - loss=rnn_1step_loss=0.54479355, rnn_1step_R2_maskV_-1.0=0.4451974, rnn_1step_CC_maskV_-1.0=0.67667711, rnn_1step_MSE_maskV_-1.0=0.54479349, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.66932565, val_rnn_1step_R2_maskV_-1.0=0.35308778, val_rnn_1step_CC_maskV_-1.0=0.6261794, learning_rate=0.001\n", + "Epoch 33/77 - loss=rnn_1step_loss=0.45849147, rnn_1step_R2_maskV_-1.0=0.53149563, rnn_1step_CC_maskV_-1.0=0.73698205, rnn_1step_MSE_maskV_-1.0=0.4584915, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57959491, val_rnn_1step_R2_maskV_-1.0=0.44106948, val_rnn_1step_CC_maskV_-1.0=0.68465811, learning_rate=0.001\n", + "Epoch 41/77 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38700238, rnn_1step_R2_maskV_-1.0=0.60363948, rnn_1step_CC_maskV_-1.0=0.78402048, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51194334, val_rnn_1step_R2_maskV_-1.0=0.50747895, val_rnn_1step_CC_maskV_-1.0=0.72669631, learning_rate=0.001\n", + "Epoch 49/77 - loss=rnn_1step_loss=0.34161028, rnn_1step_R2_maskV_-1.0=0.65024984, rnn_1step_CC_maskV_-1.0=0.81261718, rnn_1step_MSE_maskV_-1.0=0.34161031, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47849345, val_rnn_1step_R2_maskV_-1.0=0.53983659, val_rnn_1step_CC_maskV_-1.0=0.74668217, learning_rate=0.001\n", + "Epoch 57/77 - loss=rnn_1step_loss=0.30770528, rnn_1step_R2_maskV_-1.0=0.68491548, rnn_1step_CC_maskV_-1.0=0.83317077, rnn_1step_MSE_maskV_-1.0=0.30770525, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47030973, val_rnn_1step_R2_maskV_-1.0=0.54696107, val_rnn_1step_CC_maskV_-1.0=0.75261575, learning_rate=0.001\n", + "Epoch 65/77 - loss=rnn_1step_loss=0.28594783, rnn_1step_R2_maskV_-1.0=0.70733434, rnn_1step_CC_maskV_-1.0=0.84641737, rnn_1step_MSE_maskV_-1.0=0.28594786, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47273231, val_rnn_1step_R2_maskV_-1.0=0.54418606, val_rnn_1step_CC_maskV_-1.0=0.75038493, learning_rate=0.001\n", + "Epoch 73/77 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.26336417, rnn_1step_R2_maskV_-1.0=0.73117137, rnn_1step_CC_maskV_-1.0=0.8591814, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47272214, val_rnn_1step_R2_maskV_-1.0=0.54305983, val_rnn_1step_CC_maskV_-1.0=0.75198209, learning_rate=0.001\n", + "Epoch 77/77 - loss=rnn_1step_loss=0.25980899, rnn_1step_R2_maskV_-1.0=0.73475564, rnn_1step_CC_maskV_-1.0=0.86143219, rnn_1step_MSE_maskV_-1.0=0.25980896, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47238478, val_rnn_1step_R2_maskV_-1.0=0.54297125, val_rnn_1step_CC_maskV_-1.0=0.75216055, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:31:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 11.10s\n", + "\u001b[32m2025-05-30 16:31:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:32:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 104 (stopped at 119 epochs).\n", + "\u001b[32m2025-05-30 16:32:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/120 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0050329, rnn_1_1step_R2_maskV_-1.0=-0.010421287, rnn_1_1step_CC_maskV_-1.0=0.11833708, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0893091, val_rnn_1_1step_R2_maskV_-1.0=-0.042262822, val_rnn_1_1step_CC_maskV_-1.0=0.20296396, learning_rate=0.001\n", + "Epoch 13/120 - loss=rnn_1_1step_loss=0.73710728, rnn_1_1step_R2_maskV_-1.0=0.2539494, rnn_1_1step_CC_maskV_-1.0=0.51814508, rnn_1_1step_MSE_maskV_-1.0=0.73710722, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.82418895, val_rnn_1_1step_R2_maskV_-1.0=0.20621169, val_rnn_1_1step_CC_maskV_-1.0=0.50690228, learning_rate=0.001\n", + "Epoch 25/120 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.58334017, rnn_1_1step_R2_maskV_-1.0=0.40636149, rnn_1_1step_CC_maskV_-1.0=0.64905286, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.72585535, val_rnn_1_1step_R2_maskV_-1.0=0.29707843, val_rnn_1_1step_CC_maskV_-1.0=0.58597153, learning_rate=0.001\n", + "Epoch 37/120 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.47734782, rnn_1_1step_R2_maskV_-1.0=0.51254213, rnn_1_1step_CC_maskV_-1.0=0.72475195, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.62398189, val_rnn_1_1step_R2_maskV_-1.0=0.39734963, val_rnn_1_1step_CC_maskV_-1.0=0.65491521, learning_rate=0.001\n", + "Epoch 49/120 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39686593, rnn_1_1step_R2_maskV_-1.0=0.5938741, rnn_1_1step_CC_maskV_-1.0=0.77768898, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54193127, val_rnn_1_1step_R2_maskV_-1.0=0.47802168, val_rnn_1_1step_CC_maskV_-1.0=0.70768547, learning_rate=0.001\n", + "Epoch 61/120 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.32776874, rnn_1_1step_R2_maskV_-1.0=0.66464901, rnn_1_1step_CC_maskV_-1.0=0.82111073, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48668075, val_rnn_1_1step_R2_maskV_-1.0=0.53266168, val_rnn_1_1step_CC_maskV_-1.0=0.74175727, learning_rate=0.001\n", + "Epoch 73/120 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.28111854, rnn_1_1step_R2_maskV_-1.0=0.71306771, rnn_1_1step_CC_maskV_-1.0=0.848997, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47002149, val_rnn_1_1step_R2_maskV_-1.0=0.5486623, val_rnn_1_1step_CC_maskV_-1.0=0.75285977, learning_rate=0.001\n", + "Epoch 85/120 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.25752571, rnn_1_1step_R2_maskV_-1.0=0.7374711, rnn_1_1step_CC_maskV_-1.0=0.86295521, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45299616, val_rnn_1_1step_R2_maskV_-1.0=0.56489944, val_rnn_1_1step_CC_maskV_-1.0=0.76403904, learning_rate=0.001\n", + "Epoch 97/120 - loss=rnn_1_1step_loss=0.23602767, rnn_1_1step_R2_maskV_-1.0=0.75933003, rnn_1_1step_CC_maskV_-1.0=0.8753705, rnn_1_1step_MSE_maskV_-1.0=0.23602769, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.43910483, val_rnn_1_1step_R2_maskV_-1.0=0.576747, val_rnn_1_1step_CC_maskV_-1.0=0.77147543, learning_rate=0.001\n", + "Epoch 109/120 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.2245694, rnn_1_1step_R2_maskV_-1.0=0.77061594, rnn_1_1step_CC_maskV_-1.0=0.88170457, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.43714795, val_rnn_1_1step_R2_maskV_-1.0=0.58117914, val_rnn_1_1step_CC_maskV_-1.0=0.77493453, learning_rate=0.001\n", + "Epoch 120/120 - loss=rnn_1_1step_loss=0.20778553, rnn_1_1step_R2_maskV_-1.0=0.78777266, rnn_1_1step_CC_maskV_-1.0=0.89068604, rnn_1_1step_MSE_maskV_-1.0=0.20778552, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.44274783, val_rnn_1_1step_R2_maskV_-1.0=0.57475281, val_rnn_1_1step_CC_maskV_-1.0=0.77042031, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:32:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.73s\n", + "\u001b[32m2025-05-30 16:32:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.42727366)\n", + "\u001b[32m2025-05-30 16:32:12\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.2, R2_maskV_-1.0=0.8, CC_maskV_-1.0=0.895\n", + "\u001b[32m2025-05-30 16:32:12\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.406, R2_maskV_-1.0=0.601, CC_maskV_-1.0=0.786\n", + "\u001b[32m2025-05-30 16:32:12\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:32:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:33:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 308 (stopped at 323 epochs).\n", + "\u001b[32m2025-05-30 16:33:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/324 - loss=1.4314778, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.04894042, MSE_maskV_-1.0=1.431746, val_loss=1.1121581, val_CC_maskV_-1.0=0.092635602, val_MSE_maskV_-1.0=1.1063663, learning_rate=0.001\n", + "Epoch 34/324 - loss=0.88906533, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.33875763, MSE_maskV_-1.0=0.8880623, val_loss=0.95257795, val_CC_maskV_-1.0=0.32305178, val_MSE_maskV_-1.0=0.9481799, learning_rate=0.001\n", + "Epoch 67/324 - loss=0.86748457, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36874139, MSE_maskV_-1.0=0.86784095, val_loss=0.9293794, val_CC_maskV_-1.0=0.3539907, val_MSE_maskV_-1.0=0.92524755, learning_rate=0.001\n", + "Epoch 100/324 - loss=0.85645294, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38239098, MSE_maskV_-1.0=0.85667163, val_loss=0.9176743, val_CC_maskV_-1.0=0.36702037, val_MSE_maskV_-1.0=0.91381562, learning_rate=0.001\n", + "Epoch 133/324 - loss=0.85010397, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39005616, MSE_maskV_-1.0=0.84963495, val_loss=0.90961415, val_CC_maskV_-1.0=0.37580183, val_MSE_maskV_-1.0=0.90561211, learning_rate=0.001\n", + "Epoch 166/324 - loss=0.84568936, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39511529, MSE_maskV_-1.0=0.84575218, val_loss=0.90418011, val_CC_maskV_-1.0=0.3795082, val_MSE_maskV_-1.0=0.90037352, learning_rate=0.001\n", + "Epoch 199/324 - loss=0.84232634, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39832574, MSE_maskV_-1.0=0.84151644, val_loss=0.89980477, val_CC_maskV_-1.0=0.38502082, val_MSE_maskV_-1.0=0.8959049, learning_rate=0.001\n", + "Epoch 232/324 - loss=0.83999127, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40198374, MSE_maskV_-1.0=0.84029114, val_loss=0.89669466, val_CC_maskV_-1.0=0.38641748, val_MSE_maskV_-1.0=0.8931815, learning_rate=0.001\n", + "Epoch 265/324 - loss=0.83798522, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40392554, MSE_maskV_-1.0=0.84004551, val_loss=0.89464414, val_CC_maskV_-1.0=0.3890754, val_MSE_maskV_-1.0=0.89095914, learning_rate=0.001\n", + "Epoch 298/324 - loss=0.83628148, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40578765, MSE_maskV_-1.0=0.8405295, val_loss=0.89279675, val_CC_maskV_-1.0=0.39076573, val_MSE_maskV_-1.0=0.88912147, learning_rate=0.001\n", + "Epoch 324/324 - loss=0.83526838, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40728179, MSE_maskV_-1.0=0.83464819, val_loss=0.89223206, val_CC_maskV_-1.0=0.39084825, val_MSE_maskV_-1.0=0.88861197, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:33:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 79.69s\n", + "\u001b[32m2025-05-30 16:33:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:34:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 308 (stopped at 323 epochs).\n", + "\u001b[32m2025-05-30 16:34:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/324 - loss=1.5549316, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.059369385, MSE_maskV_-1.0=1.5547079, val_loss=1.1434548, val_CC_maskV_-1.0=0.079501398, val_MSE_maskV_-1.0=1.1366049, learning_rate=0.001\n", + "Epoch 34/324 - loss=0.88756251, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34111565, MSE_maskV_-1.0=0.88655758, val_loss=0.95160902, val_CC_maskV_-1.0=0.32494417, val_MSE_maskV_-1.0=0.94708776, learning_rate=0.001\n", + "Epoch 67/324 - loss=0.86670226, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36986583, MSE_maskV_-1.0=0.86704546, val_loss=0.92909646, val_CC_maskV_-1.0=0.35460007, val_MSE_maskV_-1.0=0.92488414, learning_rate=0.001\n", + "Epoch 100/324 - loss=0.85588676, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38310459, MSE_maskV_-1.0=0.8561244, val_loss=0.9175086, val_CC_maskV_-1.0=0.36761138, val_MSE_maskV_-1.0=0.91357327, learning_rate=0.001\n", + "Epoch 133/324 - loss=0.84960771, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39072332, MSE_maskV_-1.0=0.84914291, val_loss=0.90950745, val_CC_maskV_-1.0=0.37621865, val_MSE_maskV_-1.0=0.9054541, learning_rate=0.001\n", + "Epoch 166/324 - loss=0.84523189, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39572611, MSE_maskV_-1.0=0.84529811, val_loss=0.90410542, val_CC_maskV_-1.0=0.37984464, val_MSE_maskV_-1.0=0.90026528, learning_rate=0.001\n", + "Epoch 199/324 - loss=0.84190869, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39888987, MSE_maskV_-1.0=0.84109992, val_loss=0.89973372, val_CC_maskV_-1.0=0.38536581, val_MSE_maskV_-1.0=0.89579767, learning_rate=0.001\n", + "Epoch 232/324 - loss=0.83960676, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40248993, MSE_maskV_-1.0=0.83990204, val_loss=0.89662808, val_CC_maskV_-1.0=0.38671699, val_MSE_maskV_-1.0=0.89308554, learning_rate=0.001\n", + "Epoch 265/324 - loss=0.83762586, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40439436, MSE_maskV_-1.0=0.83968884, val_loss=0.8945865, val_CC_maskV_-1.0=0.38932106, val_MSE_maskV_-1.0=0.89088517, learning_rate=0.001\n", + "Epoch 298/324 - loss=0.83595532, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4062044, MSE_maskV_-1.0=0.84021097, val_loss=0.89274359, val_CC_maskV_-1.0=0.39101014, val_MSE_maskV_-1.0=0.88905132, learning_rate=0.001\n", + "Epoch 324/324 - loss=0.83496034, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40769225, MSE_maskV_-1.0=0.83433694, val_loss=0.89215744, val_CC_maskV_-1.0=0.39109445, val_MSE_maskV_-1.0=0.88852435, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:34:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 79.59s\n", + "\u001b[32m2025-05-30 16:34:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.89135253)\n", + "\u001b[32m2025-05-30 16:34:52\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 770us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:34:52\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.834, R2_maskV_-1.0=0.166, CC_maskV_-1.0=0.409\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 786us/step\n", + "51/51 [==============================] - 0s 799us/step\n", + "84/84 [==============================] - 0s 707us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:34:53\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_uAK1HL64U_ErSV16\" (6/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_uAK1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:34:53\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_ACz1HL64U_ErSV16\" (7/16)\n", + "\u001b[32m2025-05-30 16:34:53\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:34:53\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:34:53\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:34:53\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:34:53\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:34:53\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:34:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:35:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 126 (stopped at 141 epochs).\n", + "\u001b[32m2025-05-30 16:35:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/142 - loss=rnn_1step_loss=1.005927, rnn_1step_R2_maskV_-1.0=-0.01134235, rnn_1step_CC_maskV_-1.0=0.0091314018, rnn_1step_MSE_maskV_-1.0=1.0059268, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0902034, val_rnn_1step_R2_maskV_-1.0=-0.043075472, val_rnn_1step_CC_maskV_-1.0=0.13830124, learning_rate=0.001\n", + "Epoch 16/142 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.71947366, rnn_1step_R2_maskV_-1.0=0.27244785, rnn_1step_CC_maskV_-1.0=0.53773057, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.82301092, val_rnn_1step_R2_maskV_-1.0=0.21079229, val_rnn_1step_CC_maskV_-1.0=0.50851554, learning_rate=0.001\n", + "Epoch 31/142 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.53456932, rnn_1step_R2_maskV_-1.0=0.45716983, rnn_1step_CC_maskV_-1.0=0.68403107, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64838743, val_rnn_1step_R2_maskV_-1.0=0.37712261, val_rnn_1step_CC_maskV_-1.0=0.63905585, learning_rate=0.001\n", + "Epoch 46/142 - loss=rnn_1step_loss=0.47177768, rnn_1step_R2_maskV_-1.0=0.51967382, rnn_1step_CC_maskV_-1.0=0.72824508, rnn_1step_MSE_maskV_-1.0=0.47177765, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57702231, val_rnn_1step_R2_maskV_-1.0=0.44649205, val_rnn_1step_CC_maskV_-1.0=0.68501252, learning_rate=0.001\n", + "Epoch 61/142 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42421153, rnn_1step_R2_maskV_-1.0=0.56742591, rnn_1step_CC_maskV_-1.0=0.76001006, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52867454, val_rnn_1step_R2_maskV_-1.0=0.49171448, val_rnn_1step_CC_maskV_-1.0=0.71623653, learning_rate=0.001\n", + "Epoch 76/142 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.38871631, rnn_1step_R2_maskV_-1.0=0.60212755, rnn_1step_CC_maskV_-1.0=0.78370368, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49609423, val_rnn_1step_R2_maskV_-1.0=0.52273226, val_rnn_1step_CC_maskV_-1.0=0.7373786, learning_rate=0.001\n", + "Epoch 91/142 - loss=rnn_1step_loss=0.36010206, rnn_1step_R2_maskV_-1.0=0.63171721, rnn_1step_CC_maskV_-1.0=0.80094934, rnn_1step_MSE_maskV_-1.0=0.36010203, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48142335, val_rnn_1step_R2_maskV_-1.0=0.53760624, val_rnn_1step_CC_maskV_-1.0=0.7458362, learning_rate=0.001\n", + "Epoch 106/142 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33806387, rnn_1step_R2_maskV_-1.0=0.65371752, rnn_1step_CC_maskV_-1.0=0.81468201, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47577918, val_rnn_1step_R2_maskV_-1.0=0.5427354, val_rnn_1step_CC_maskV_-1.0=0.74860674, learning_rate=0.001\n", + "Epoch 121/142 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32386473, rnn_1step_R2_maskV_-1.0=0.66791904, rnn_1step_CC_maskV_-1.0=0.8246187, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45551118, val_rnn_1step_R2_maskV_-1.0=0.56178832, val_rnn_1step_CC_maskV_-1.0=0.76686358, learning_rate=0.001\n", + "Epoch 136/142 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31093436, rnn_1step_R2_maskV_-1.0=0.68114585, rnn_1step_CC_maskV_-1.0=0.83167541, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45145008, val_rnn_1step_R2_maskV_-1.0=0.56684786, val_rnn_1step_CC_maskV_-1.0=0.7690683, learning_rate=0.001\n", + "Epoch 142/142 - loss=rnn_1step_loss=0.3100456, rnn_1step_R2_maskV_-1.0=0.68215567, rnn_1step_CC_maskV_-1.0=0.83168232, rnn_1step_MSE_maskV_-1.0=0.31004563, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47140989, val_rnn_1step_R2_maskV_-1.0=0.54602784, val_rnn_1step_CC_maskV_-1.0=0.75108719, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:35:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 18.28s\n", + "\u001b[32m2025-05-30 16:35:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:35:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 153 (stopped at 168 epochs).\n", + "\u001b[32m2025-05-30 16:35:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/169 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0050216, rnn_1_1step_R2_maskV_-1.0=-0.010420229, rnn_1_1step_CC_maskV_-1.0=0.11647355, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0889286, val_rnn_1_1step_R2_maskV_-1.0=-0.041854441, val_rnn_1_1step_CC_maskV_-1.0=0.22588052, learning_rate=0.001\n", + "Epoch 18/169 - loss=rnn_1_1step_loss=0.73121834, rnn_1_1step_R2_maskV_-1.0=0.25764272, rnn_1_1step_CC_maskV_-1.0=0.52261043, rnn_1_1step_MSE_maskV_-1.0=0.73121828, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.8457548, val_rnn_1_1step_R2_maskV_-1.0=0.19597164, val_rnn_1_1step_CC_maskV_-1.0=0.47531909, learning_rate=0.001\n", + "Epoch 35/169 - loss=rnn_1_1step_loss=0.52281922, rnn_1_1step_R2_maskV_-1.0=0.46752059, rnn_1_1step_CC_maskV_-1.0=0.69253612, rnn_1_1step_MSE_maskV_-1.0=0.52281916, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.64356321, val_rnn_1_1step_R2_maskV_-1.0=0.384799, val_rnn_1_1step_CC_maskV_-1.0=0.63976085, learning_rate=0.001\n", + "Epoch 52/169 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.46566913, rnn_1_1step_R2_maskV_-1.0=0.52490312, rnn_1_1step_CC_maskV_-1.0=0.73251092, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59054548, val_rnn_1_1step_R2_maskV_-1.0=0.43409079, val_rnn_1_1step_CC_maskV_-1.0=0.68215656, learning_rate=0.001\n", + "Epoch 69/169 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.43095669, rnn_1_1step_R2_maskV_-1.0=0.55969548, rnn_1_1step_CC_maskV_-1.0=0.75557172, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53070831, val_rnn_1_1step_R2_maskV_-1.0=0.49244368, val_rnn_1_1step_CC_maskV_-1.0=0.71499294, learning_rate=0.001\n", + "Epoch 86/169 - loss=rnn_1_1step_loss=0.40874633, rnn_1_1step_R2_maskV_-1.0=0.58184648, rnn_1_1step_CC_maskV_-1.0=0.7702297, rnn_1_1step_MSE_maskV_-1.0=0.4087463, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51017338, val_rnn_1_1step_R2_maskV_-1.0=0.51194912, val_rnn_1_1step_CC_maskV_-1.0=0.72801107, learning_rate=0.001\n", + "Epoch 103/169 - loss=rnn_1_1step_loss=0.39750281, rnn_1_1step_R2_maskV_-1.0=0.59350753, rnn_1_1step_CC_maskV_-1.0=0.77732605, rnn_1_1step_MSE_maskV_-1.0=0.39750284, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50003773, val_rnn_1_1step_R2_maskV_-1.0=0.52177948, val_rnn_1_1step_CC_maskV_-1.0=0.73432136, learning_rate=0.001\n", + "Epoch 120/169 - loss=rnn_1_1step_loss=0.38531145, rnn_1_1step_R2_maskV_-1.0=0.60591143, rnn_1_1step_CC_maskV_-1.0=0.78515208, rnn_1_1step_MSE_maskV_-1.0=0.38531148, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49509692, val_rnn_1_1step_R2_maskV_-1.0=0.52620488, val_rnn_1_1step_CC_maskV_-1.0=0.73635978, learning_rate=0.001\n", + "Epoch 137/169 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.37245372, rnn_1_1step_R2_maskV_-1.0=0.61809695, rnn_1_1step_CC_maskV_-1.0=0.79350334, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48157057, val_rnn_1_1step_R2_maskV_-1.0=0.53920007, val_rnn_1_1step_CC_maskV_-1.0=0.74715054, learning_rate=0.001\n", + "Epoch 154/169 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.3659614, rnn_1_1step_R2_maskV_-1.0=0.62477475, rnn_1_1step_CC_maskV_-1.0=0.79733509, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47760859, val_rnn_1_1step_R2_maskV_-1.0=0.54323852, val_rnn_1_1step_CC_maskV_-1.0=0.75056732, learning_rate=0.001\n", + "Epoch 169/169 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.35209858, rnn_1_1step_R2_maskV_-1.0=0.63896286, rnn_1_1step_CC_maskV_-1.0=0.80695254, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46070898, val_rnn_1_1step_R2_maskV_-1.0=0.56022614, val_rnn_1_1step_CC_maskV_-1.0=0.75631231, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:35:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 20.98s\n", + "\u001b[32m2025-05-30 16:35:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.45095253)\n", + "\u001b[32m2025-05-30 16:35:34\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.293, R2_maskV_-1.0=0.707, CC_maskV_-1.0=0.842\n", + "\u001b[32m2025-05-30 16:35:34\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.439, R2_maskV_-1.0=0.569, CC_maskV_-1.0=0.77\n", + "\u001b[32m2025-05-30 16:35:34\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:35:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:36:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 98 (stopped at 113 epochs).\n", + "\u001b[32m2025-05-30 16:36:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/114 - loss=2.6514046, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.039682116, MSE_maskV_-1.0=2.6481874, val_loss=1.3262827, val_CC_maskV_-1.0=0.087068014, val_MSE_maskV_-1.0=1.3201194, learning_rate=0.001\n", + "Epoch 13/114 - loss=0.78466171, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46355236, MSE_maskV_-1.0=0.7839877, val_loss=0.83189183, val_CC_maskV_-1.0=0.44753814, val_MSE_maskV_-1.0=0.82944369, learning_rate=0.001\n", + "Epoch 25/114 - loss=0.7439605, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50623906, MSE_maskV_-1.0=0.74357909, val_loss=0.78918213, val_CC_maskV_-1.0=0.48780251, val_MSE_maskV_-1.0=0.78712827, learning_rate=0.001\n", + "Epoch 37/114 - loss=0.72720295, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52222085, MSE_maskV_-1.0=0.7273519, val_loss=0.77155423, val_CC_maskV_-1.0=0.50144356, val_MSE_maskV_-1.0=0.76985282, learning_rate=0.001\n", + "Epoch 49/114 - loss=0.71962059, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52956086, MSE_maskV_-1.0=0.71944785, val_loss=0.76253968, val_CC_maskV_-1.0=0.50907087, val_MSE_maskV_-1.0=0.76083606, learning_rate=0.001\n", + "Epoch 61/114 - loss=0.71520263, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53284061, MSE_maskV_-1.0=0.71506739, val_loss=0.75830108, val_CC_maskV_-1.0=0.51146013, val_MSE_maskV_-1.0=0.75665402, learning_rate=0.001\n", + "Epoch 73/114 - loss=0.71291292, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53503329, MSE_maskV_-1.0=0.71268845, val_loss=0.75708747, val_CC_maskV_-1.0=0.5120883, val_MSE_maskV_-1.0=0.75560707, learning_rate=0.001\n", + "Epoch 85/114 - loss=0.71152782, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53610957, MSE_maskV_-1.0=0.71180958, val_loss=0.75350821, val_CC_maskV_-1.0=0.51500958, val_MSE_maskV_-1.0=0.75212294, learning_rate=0.001\n", + "Epoch 97/114 - loss=0.71033436, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53753883, MSE_maskV_-1.0=0.71035486, val_loss=0.75402004, val_CC_maskV_-1.0=0.51446515, val_MSE_maskV_-1.0=0.75254148, learning_rate=0.001\n", + "Epoch 109/114 - loss=0.7099871, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53685427, MSE_maskV_-1.0=0.71000373, val_loss=0.75200534, val_CC_maskV_-1.0=0.51594877, val_MSE_maskV_-1.0=0.75069481, learning_rate=0.001\n", + "Epoch 114/114 - loss=0.70950305, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53812301, MSE_maskV_-1.0=0.7087875, val_loss=0.75413531, val_CC_maskV_-1.0=0.51429158, val_MSE_maskV_-1.0=0.75277686, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:36:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 28.76s\n", + "\u001b[32m2025-05-30 16:36:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:36:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 98 (stopped at 113 epochs).\n", + "\u001b[32m2025-05-30 16:36:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/114 - loss=2.7759318, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.025179826, MSE_maskV_-1.0=2.7725987, val_loss=1.3572278, val_CC_maskV_-1.0=0.063723266, val_MSE_maskV_-1.0=1.3456309, learning_rate=0.001\n", + "Epoch 13/114 - loss=0.78761357, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46046004, MSE_maskV_-1.0=0.78692853, val_loss=0.83872253, val_CC_maskV_-1.0=0.4446294, val_MSE_maskV_-1.0=0.83581573, learning_rate=0.001\n", + "Epoch 25/114 - loss=0.74602783, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50425696, MSE_maskV_-1.0=0.74564135, val_loss=0.79263395, val_CC_maskV_-1.0=0.48607412, val_MSE_maskV_-1.0=0.79036766, learning_rate=0.001\n", + "Epoch 37/114 - loss=0.72828686, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52126396, MSE_maskV_-1.0=0.72841495, val_loss=0.77350539, val_CC_maskV_-1.0=0.50013953, val_MSE_maskV_-1.0=0.77167922, learning_rate=0.001\n", + "Epoch 49/114 - loss=0.72014952, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52912676, MSE_maskV_-1.0=0.71995705, val_loss=0.76377964, val_CC_maskV_-1.0=0.50810009, val_MSE_maskV_-1.0=0.76199669, learning_rate=0.001\n", + "Epoch 61/114 - loss=0.71548146, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5326612, MSE_maskV_-1.0=0.71534985, val_loss=0.75914067, val_CC_maskV_-1.0=0.51079816, val_MSE_maskV_-1.0=0.75741434, learning_rate=0.001\n", + "Epoch 73/114 - loss=0.71308243, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53488237, MSE_maskV_-1.0=0.71285594, val_loss=0.75772005, val_CC_maskV_-1.0=0.51148945, val_MSE_maskV_-1.0=0.75618345, learning_rate=0.001\n", + "Epoch 85/114 - loss=0.71162915, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5360359, MSE_maskV_-1.0=0.71191001, val_loss=0.75404257, val_CC_maskV_-1.0=0.5145241, val_MSE_maskV_-1.0=0.75260848, learning_rate=0.001\n", + "Epoch 97/114 - loss=0.71039838, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53747874, MSE_maskV_-1.0=0.71042836, val_loss=0.7544803, val_CC_maskV_-1.0=0.51400596, val_MSE_maskV_-1.0=0.75295794, learning_rate=0.001\n", + "Epoch 109/114 - loss=0.71003193, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53681207, MSE_maskV_-1.0=0.71005118, val_loss=0.75238287, val_CC_maskV_-1.0=0.51556605, val_MSE_maskV_-1.0=0.75104189, learning_rate=0.001\n", + "Epoch 114/114 - loss=0.70955306, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53808004, MSE_maskV_-1.0=0.70883256, val_loss=0.75450468, val_CC_maskV_-1.0=0.5139522, val_MSE_maskV_-1.0=0.75311136, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:36:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 28.97s\n", + "\u001b[32m2025-05-30 16:36:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.75189263)\n", + "\u001b[32m2025-05-30 16:36:32\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 767us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:36:32\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.708, R2_maskV_-1.0=0.292, CC_maskV_-1.0=0.541\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 749us/step\n", + "51/51 [==============================] - 0s 838us/step\n", + "84/84 [==============================] - 0s 727us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:36:33\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_ACz1HL64U_ErSV16\" (7/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_ACz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:36:33\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_ACy1HL64U_ErSV16\" (8/16)\n", + "\u001b[32m2025-05-30 16:36:33\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:36:33\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:36:33\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:36:33\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:36:33\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:36:33\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:36:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:36:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 188 (stopped at 203 epochs).\n", + "\u001b[32m2025-05-30 16:36:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/204 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0016676, rnn_1step_R2_maskV_-1.0=-0.0069474392, rnn_1step_CC_maskV_-1.0=0.095009327, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0810879, val_rnn_1step_R2_maskV_-1.0=-0.034509271, val_rnn_1step_CC_maskV_-1.0=0.18447173, learning_rate=0.001\n", + "Epoch 22/204 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.61954218, rnn_1step_R2_maskV_-1.0=0.37116364, rnn_1step_CC_maskV_-1.0=0.62000704, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.73408192, val_rnn_1step_R2_maskV_-1.0=0.29797107, val_rnn_1step_CC_maskV_-1.0=0.57785428, learning_rate=0.001\n", + "Epoch 43/204 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.50970322, rnn_1step_R2_maskV_-1.0=0.4811365, rnn_1step_CC_maskV_-1.0=0.70197356, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.63694376, val_rnn_1step_R2_maskV_-1.0=0.39157999, val_rnn_1step_CC_maskV_-1.0=0.64391816, learning_rate=0.001\n", + "Epoch 64/204 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.45538959, rnn_1step_R2_maskV_-1.0=0.5359816, rnn_1step_CC_maskV_-1.0=0.7399174, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5998885, val_rnn_1step_R2_maskV_-1.0=0.42711738, val_rnn_1step_CC_maskV_-1.0=0.66892445, learning_rate=0.001\n", + "Epoch 85/204 - loss=rnn_1step_loss=0.42756465, rnn_1step_R2_maskV_-1.0=0.56332946, rnn_1step_CC_maskV_-1.0=0.7584427, rnn_1step_MSE_maskV_-1.0=0.42756468, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57661676, val_rnn_1step_R2_maskV_-1.0=0.44955665, val_rnn_1step_CC_maskV_-1.0=0.68388057, learning_rate=0.001\n", + "Epoch 106/204 - loss=rnn_1step_loss=0.39167342, rnn_1step_R2_maskV_-1.0=0.5991509, rnn_1step_CC_maskV_-1.0=0.78158486, rnn_1step_MSE_maskV_-1.0=0.39167345, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53015727, val_rnn_1step_R2_maskV_-1.0=0.49347618, val_rnn_1step_CC_maskV_-1.0=0.71655375, learning_rate=0.001\n", + "Epoch 127/204 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35933554, rnn_1step_R2_maskV_-1.0=0.63164449, rnn_1step_CC_maskV_-1.0=0.80190897, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.49466696, val_rnn_1step_R2_maskV_-1.0=0.52734482, val_rnn_1step_CC_maskV_-1.0=0.73994541, learning_rate=0.001\n", + "Epoch 148/204 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34512484, rnn_1step_R2_maskV_-1.0=0.64643294, rnn_1step_CC_maskV_-1.0=0.81110787, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47401437, val_rnn_1step_R2_maskV_-1.0=0.5463621, val_rnn_1step_CC_maskV_-1.0=0.74960726, learning_rate=0.001\n", + "Epoch 169/204 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33486152, rnn_1step_R2_maskV_-1.0=0.65702885, rnn_1step_CC_maskV_-1.0=0.81717217, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45578408, val_rnn_1step_R2_maskV_-1.0=0.56310904, val_rnn_1step_CC_maskV_-1.0=0.75999755, learning_rate=0.001\n", + "Epoch 190/204 - loss=rnn_1step_loss=0.33439288, rnn_1step_R2_maskV_-1.0=0.65686417, rnn_1step_CC_maskV_-1.0=0.81782848, rnn_1step_MSE_maskV_-1.0=0.33439291, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45717332, val_rnn_1step_R2_maskV_-1.0=0.56083584, val_rnn_1step_CC_maskV_-1.0=0.76317841, learning_rate=0.001\n", + "Epoch 204/204 - loss=rnn_1step_loss=0.32421684, rnn_1step_R2_maskV_-1.0=0.66748542, rnn_1step_CC_maskV_-1.0=0.8243829, rnn_1step_MSE_maskV_-1.0=0.32421687, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44877133, val_rnn_1step_R2_maskV_-1.0=0.56913781, val_rnn_1step_CC_maskV_-1.0=0.76583582, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:36:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 23.19s\n", + "\u001b[32m2025-05-30 16:36:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:37:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 113 (stopped at 128 epochs).\n", + "\u001b[32m2025-05-30 16:37:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.000563, rnn_1_1step_R2_maskV_-1.0=-0.005776383, rnn_1_1step_CC_maskV_-1.0=0.12427357, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0827546, val_rnn_1_1step_R2_maskV_-1.0=-0.036285862, val_rnn_1_1step_CC_maskV_-1.0=0.173026, learning_rate=0.001\n", + "Epoch 14/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.75425076, rnn_1_1step_R2_maskV_-1.0=0.24058984, rnn_1_1step_CC_maskV_-1.0=0.51305604, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.83625841, val_rnn_1_1step_R2_maskV_-1.0=0.19519845, val_rnn_1_1step_CC_maskV_-1.0=0.49983409, learning_rate=0.001\n", + "Epoch 27/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.55046999, rnn_1_1step_R2_maskV_-1.0=0.44106758, rnn_1_1step_CC_maskV_-1.0=0.67183399, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.66834974, val_rnn_1_1step_R2_maskV_-1.0=0.35801244, val_rnn_1_1step_CC_maskV_-1.0=0.62125933, learning_rate=0.001\n", + "Epoch 40/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.48993596, rnn_1_1step_R2_maskV_-1.0=0.50188673, rnn_1_1step_CC_maskV_-1.0=0.71533465, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63365573, val_rnn_1_1step_R2_maskV_-1.0=0.39257568, val_rnn_1_1step_CC_maskV_-1.0=0.64545423, learning_rate=0.001\n", + "Epoch 53/129 - loss=rnn_1_1step_loss=0.44340432, rnn_1_1step_R2_maskV_-1.0=0.54881263, rnn_1_1step_CC_maskV_-1.0=0.74713778, rnn_1_1step_MSE_maskV_-1.0=0.44340429, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60106659, val_rnn_1_1step_R2_maskV_-1.0=0.4244749, val_rnn_1_1step_CC_maskV_-1.0=0.66762936, learning_rate=0.001\n", + "Epoch 66/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.4109081, rnn_1_1step_R2_maskV_-1.0=0.58091664, rnn_1_1step_CC_maskV_-1.0=0.76868427, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5735274, val_rnn_1_1step_R2_maskV_-1.0=0.45035514, val_rnn_1_1step_CC_maskV_-1.0=0.68668437, learning_rate=0.001\n", + "Epoch 79/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.39254883, rnn_1_1step_R2_maskV_-1.0=0.59939468, rnn_1_1step_CC_maskV_-1.0=0.78096879, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56766909, val_rnn_1_1step_R2_maskV_-1.0=0.45508859, val_rnn_1_1step_CC_maskV_-1.0=0.69004017, learning_rate=0.001\n", + "Epoch 92/129 - loss=rnn_1_1step_loss=0.37704015, rnn_1_1step_R2_maskV_-1.0=0.61465096, rnn_1_1step_CC_maskV_-1.0=0.79112339, rnn_1_1step_MSE_maskV_-1.0=0.37704018, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53751874, val_rnn_1_1step_R2_maskV_-1.0=0.48369241, val_rnn_1_1step_CC_maskV_-1.0=0.71239823, learning_rate=0.001\n", + "Epoch 105/129 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36921811, rnn_1_1step_R2_maskV_-1.0=0.6222468, rnn_1_1step_CC_maskV_-1.0=0.79574305, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5432058, val_rnn_1_1step_R2_maskV_-1.0=0.47756302, val_rnn_1_1step_CC_maskV_-1.0=0.71518618, learning_rate=0.001\n", + "Epoch 118/129 - loss=rnn_1_1step_loss=0.34885034, rnn_1_1step_R2_maskV_-1.0=0.64214927, rnn_1_1step_CC_maskV_-1.0=0.80791438, rnn_1_1step_MSE_maskV_-1.0=0.34885031, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50878125, val_rnn_1_1step_R2_maskV_-1.0=0.51110554, val_rnn_1_1step_CC_maskV_-1.0=0.73142946, learning_rate=0.001\n", + "Epoch 129/129 - loss=rnn_1_1step_loss=0.34216174, rnn_1_1step_R2_maskV_-1.0=0.64941972, rnn_1_1step_CC_maskV_-1.0=0.81238383, rnn_1_1step_MSE_maskV_-1.0=0.34216177, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5228774, val_rnn_1_1step_R2_maskV_-1.0=0.49625307, val_rnn_1_1step_CC_maskV_-1.0=0.72108591, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:37:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 15.72s\n", + "\u001b[32m2025-05-30 16:37:13\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.44406089)\n", + "\u001b[32m2025-05-30 16:37:14\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.292, R2_maskV_-1.0=0.707, CC_maskV_-1.0=0.843\n", + "\u001b[32m2025-05-30 16:37:14\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.432, R2_maskV_-1.0=0.578, CC_maskV_-1.0=0.77\n", + "\u001b[32m2025-05-30 16:37:14\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:37:14\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:37:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 86 (stopped at 101 epochs).\n", + "\u001b[32m2025-05-30 16:37:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/102 - loss=1.4045837, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.099927388, MSE_maskV_-1.0=1.4046494, val_loss=1.0724815, val_CC_maskV_-1.0=0.16808929, val_MSE_maskV_-1.0=1.0656533, learning_rate=0.001\n", + "Epoch 12/102 - loss=0.75172836, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49751559, MSE_maskV_-1.0=0.75231522, val_loss=0.81541944, val_CC_maskV_-1.0=0.46060881, val_MSE_maskV_-1.0=0.81178105, learning_rate=0.001\n", + "Epoch 23/102 - loss=0.70416301, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54344088, MSE_maskV_-1.0=0.70351863, val_loss=0.77459204, val_CC_maskV_-1.0=0.50221944, val_MSE_maskV_-1.0=0.77078545, learning_rate=0.001\n", + "Epoch 34/102 - loss=0.68576902, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55957925, MSE_maskV_-1.0=0.68518335, val_loss=0.75546861, val_CC_maskV_-1.0=0.5195083, val_MSE_maskV_-1.0=0.75163823, learning_rate=0.001\n", + "Epoch 45/102 - loss=0.67565149, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5684467, MSE_maskV_-1.0=0.67522722, val_loss=0.7492972, val_CC_maskV_-1.0=0.52499795, val_MSE_maskV_-1.0=0.74572879, learning_rate=0.001\n", + "Epoch 56/102 - loss=0.66902435, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57424557, MSE_maskV_-1.0=0.66882879, val_loss=0.74422944, val_CC_maskV_-1.0=0.52910197, val_MSE_maskV_-1.0=0.74066305, learning_rate=0.001\n", + "Epoch 67/102 - loss=0.66449833, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5776149, MSE_maskV_-1.0=0.66510296, val_loss=0.7379247, val_CC_maskV_-1.0=0.53490043, val_MSE_maskV_-1.0=0.73440701, learning_rate=0.001\n", + "Epoch 78/102 - loss=0.66056508, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58150762, MSE_maskV_-1.0=0.66038197, val_loss=0.73855263, val_CC_maskV_-1.0=0.53469515, val_MSE_maskV_-1.0=0.73508745, learning_rate=0.001\n", + "Epoch 89/102 - loss=0.65624732, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58485353, MSE_maskV_-1.0=0.65650111, val_loss=0.73817462, val_CC_maskV_-1.0=0.53517997, val_MSE_maskV_-1.0=0.73475671, learning_rate=0.001\n", + "Epoch 100/102 - loss=0.65393186, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5870406, MSE_maskV_-1.0=0.65408933, val_loss=0.73648036, val_CC_maskV_-1.0=0.53552985, val_MSE_maskV_-1.0=0.73331356, learning_rate=0.001\n", + "Epoch 102/102 - loss=0.65349913, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58738512, MSE_maskV_-1.0=0.65317965, val_loss=0.73667395, val_CC_maskV_-1.0=0.5369733, val_MSE_maskV_-1.0=0.73313963, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:37:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 27.77s\n", + "\u001b[32m2025-05-30 16:37:42\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:38:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 151 (stopped at 166 epochs).\n", + "\u001b[32m2025-05-30 16:38:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/167 - loss=1.3647346, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.10817865, MSE_maskV_-1.0=1.3649347, val_loss=1.069379, val_CC_maskV_-1.0=0.17611377, val_MSE_maskV_-1.0=1.062122, learning_rate=0.001\n", + "Epoch 18/167 - loss=0.72002316, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52842945, MSE_maskV_-1.0=0.71983701, val_loss=0.78650564, val_CC_maskV_-1.0=0.48865578, val_MSE_maskV_-1.0=0.78289092, learning_rate=0.001\n", + "Epoch 35/167 - loss=0.6823681, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56222725, MSE_maskV_-1.0=0.68243736, val_loss=0.7602101, val_CC_maskV_-1.0=0.51642662, val_MSE_maskV_-1.0=0.75637114, learning_rate=0.001\n", + "Epoch 52/167 - loss=0.66951764, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57351577, MSE_maskV_-1.0=0.66955763, val_loss=0.74627978, val_CC_maskV_-1.0=0.52826935, val_MSE_maskV_-1.0=0.74264586, learning_rate=0.001\n", + "Epoch 69/167 - loss=0.66244656, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57968235, MSE_maskV_-1.0=0.66239518, val_loss=0.74483585, val_CC_maskV_-1.0=0.52946597, val_MSE_maskV_-1.0=0.74093777, learning_rate=0.001\n", + "Epoch 86/167 - loss=0.65584064, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58530968, MSE_maskV_-1.0=0.65626389, val_loss=0.73574799, val_CC_maskV_-1.0=0.53756487, val_MSE_maskV_-1.0=0.73204535, learning_rate=0.001\n", + "Epoch 103/167 - loss=0.65184945, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58868861, MSE_maskV_-1.0=0.65188682, val_loss=0.73493201, val_CC_maskV_-1.0=0.53712571, val_MSE_maskV_-1.0=0.73143768, learning_rate=0.001\n", + "Epoch 120/167 - loss=0.64649916, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59329301, MSE_maskV_-1.0=0.64616287, val_loss=0.73631573, val_CC_maskV_-1.0=0.53870684, val_MSE_maskV_-1.0=0.73263645, learning_rate=0.001\n", + "Epoch 137/167 - loss=0.64384693, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59480727, MSE_maskV_-1.0=0.64321584, val_loss=0.72812802, val_CC_maskV_-1.0=0.54432881, val_MSE_maskV_-1.0=0.72469211, learning_rate=0.001\n", + "Epoch 154/167 - loss=0.64034295, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5977146, MSE_maskV_-1.0=0.64019632, val_loss=0.72885984, val_CC_maskV_-1.0=0.54344952, val_MSE_maskV_-1.0=0.72552878, learning_rate=0.001\n", + "Epoch 167/167 - loss=0.63976711, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.598028, MSE_maskV_-1.0=0.63946867, val_loss=0.72969186, val_CC_maskV_-1.0=0.54285043, val_MSE_maskV_-1.0=0.7264818, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:38:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 43.99s\n", + "\u001b[32m2025-05-30 16:38:26\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.72422457)\n", + "\u001b[32m2025-05-30 16:38:26\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 785us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:38:26\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.634, R2_maskV_-1.0=0.367, CC_maskV_-1.0=0.606\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 831us/step\n", + "51/51 [==============================] - 0s 852us/step\n", + "84/84 [==============================] - 0s 811us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:38:27\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_ACy1HL64U_ErSV16\" (8/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_ACy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:38:27\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_KCz1HL64U_ErSV16\" (9/16)\n", + "\u001b[32m2025-05-30 16:38:27\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:38:27\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:38:27\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:38:27\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:38:27\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:38:27\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:38:27\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:38:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 137 (stopped at 152 epochs).\n", + "\u001b[32m2025-05-30 16:38:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/153 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0057729, rnn_1step_R2_maskV_-1.0=-0.0112109, rnn_1step_CC_maskV_-1.0=0.093421109, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0907503, val_rnn_1step_R2_maskV_-1.0=-0.043607652, val_rnn_1step_CC_maskV_-1.0=0.25487763, learning_rate=0.001\n", + "Epoch 17/153 - loss=rnn_1step_loss=0.70804065, rnn_1step_R2_maskV_-1.0=0.28269073, rnn_1step_CC_maskV_-1.0=0.54432678, rnn_1step_MSE_maskV_-1.0=0.7080406, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.82125974, val_rnn_1step_R2_maskV_-1.0=0.21158153, val_rnn_1step_CC_maskV_-1.0=0.50306493, learning_rate=0.001\n", + "Epoch 33/153 - loss=rnn_1step_loss=0.53958374, rnn_1step_R2_maskV_-1.0=0.45156261, rnn_1step_CC_maskV_-1.0=0.68120819, rnn_1step_MSE_maskV_-1.0=0.5395838, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6702826, val_rnn_1step_R2_maskV_-1.0=0.35561639, val_rnn_1step_CC_maskV_-1.0=0.61926758, learning_rate=0.001\n", + "Epoch 49/153 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.41639665, rnn_1step_R2_maskV_-1.0=0.57512879, rnn_1step_CC_maskV_-1.0=0.76623541, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.54397058, val_rnn_1step_R2_maskV_-1.0=0.48027653, val_rnn_1step_CC_maskV_-1.0=0.7041626, learning_rate=0.001\n", + "Epoch 65/153 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33723316, rnn_1step_R2_maskV_-1.0=0.65505469, rnn_1step_CC_maskV_-1.0=0.81588125, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47240773, val_rnn_1step_R2_maskV_-1.0=0.54963303, val_rnn_1step_CC_maskV_-1.0=0.74951112, learning_rate=0.001\n", + "Epoch 81/153 - loss=rnn_1step_loss=0.29296187, rnn_1step_R2_maskV_-1.0=0.70080394, rnn_1step_CC_maskV_-1.0=0.84201556, rnn_1step_MSE_maskV_-1.0=0.2929619, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44725373, val_rnn_1step_R2_maskV_-1.0=0.57372379, val_rnn_1step_CC_maskV_-1.0=0.76578164, learning_rate=0.001\n", + "Epoch 97/153 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.26044926, rnn_1step_R2_maskV_-1.0=0.73429656, rnn_1step_CC_maskV_-1.0=0.86102343, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.43145052, val_rnn_1step_R2_maskV_-1.0=0.58838153, val_rnn_1step_CC_maskV_-1.0=0.77583891, learning_rate=0.001\n", + "Epoch 113/153 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.23676212, rnn_1step_R2_maskV_-1.0=0.75847208, rnn_1step_CC_maskV_-1.0=0.87445796, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.41950262, val_rnn_1step_R2_maskV_-1.0=0.59909195, val_rnn_1step_CC_maskV_-1.0=0.78242296, learning_rate=0.001\n", + "Epoch 129/153 - loss=rnn_1step_loss=0.21638446, rnn_1step_R2_maskV_-1.0=0.77918899, rnn_1step_CC_maskV_-1.0=0.88599592, rnn_1step_MSE_maskV_-1.0=0.21638444, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.41893759, val_rnn_1step_R2_maskV_-1.0=0.59988296, val_rnn_1step_CC_maskV_-1.0=0.78515244, learning_rate=0.001\n", + "Epoch 145/153 - loss=rnn_1step_loss=0.20007336, rnn_1step_R2_maskV_-1.0=0.7958883, rnn_1step_CC_maskV_-1.0=0.89516109, rnn_1step_MSE_maskV_-1.0=0.20007338, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.41573623, val_rnn_1step_R2_maskV_-1.0=0.60240692, val_rnn_1step_CC_maskV_-1.0=0.7864297, learning_rate=0.001\n", + "Epoch 153/153 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.19772625, rnn_1step_R2_maskV_-1.0=0.79827851, rnn_1step_CC_maskV_-1.0=0.89678216, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.41593829, val_rnn_1step_R2_maskV_-1.0=0.60212868, val_rnn_1step_CC_maskV_-1.0=0.78728539, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:38:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 17.41s\n", + "\u001b[32m2025-05-30 16:38:45\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:38:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 100 (stopped at 115 epochs).\n", + "\u001b[32m2025-05-30 16:38:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/116 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0059505, rnn_1_1step_R2_maskV_-1.0=-0.011380479, rnn_1_1step_CC_maskV_-1.0=0.0031438693, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0908192, val_rnn_1_1step_R2_maskV_-1.0=-0.043662727, val_rnn_1_1step_CC_maskV_-1.0=0.12950394, learning_rate=0.001\n", + "Epoch 13/116 - loss=rnn_1_1step_loss=0.8175084, rnn_1_1step_R2_maskV_-1.0=0.1732662, rnn_1_1step_CC_maskV_-1.0=0.43903214, rnn_1_1step_MSE_maskV_-1.0=0.81750834, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.86904961, val_rnn_1_1step_R2_maskV_-1.0=0.16811308, val_rnn_1_1step_CC_maskV_-1.0=0.45732009, learning_rate=0.001\n", + "Epoch 25/116 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.57797307, rnn_1_1step_R2_maskV_-1.0=0.41324145, rnn_1_1step_CC_maskV_-1.0=0.65145528, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65506607, val_rnn_1_1step_R2_maskV_-1.0=0.36540556, val_rnn_1_1step_CC_maskV_-1.0=0.62686157, learning_rate=0.001\n", + "Epoch 37/116 - loss=rnn_1_1step_loss=0.46937072, rnn_1_1step_R2_maskV_-1.0=0.52338552, rnn_1_1step_CC_maskV_-1.0=0.73017281, rnn_1_1step_MSE_maskV_-1.0=0.46937069, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5923056, val_rnn_1_1step_R2_maskV_-1.0=0.42949557, val_rnn_1_1step_CC_maskV_-1.0=0.67153823, learning_rate=0.001\n", + "Epoch 49/116 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38963804, rnn_1_1step_R2_maskV_-1.0=0.60352612, rnn_1_1step_CC_maskV_-1.0=0.78298926, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.52590269, val_rnn_1_1step_R2_maskV_-1.0=0.49557164, val_rnn_1_1step_CC_maskV_-1.0=0.71534306, learning_rate=0.001\n", + "Epoch 61/116 - loss=rnn_1_1step_loss=0.34986553, rnn_1_1step_R2_maskV_-1.0=0.64373332, rnn_1_1step_CC_maskV_-1.0=0.80786514, rnn_1_1step_MSE_maskV_-1.0=0.3498655, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50574952, val_rnn_1_1step_R2_maskV_-1.0=0.51452953, val_rnn_1_1step_CC_maskV_-1.0=0.72902912, learning_rate=0.001\n", + "Epoch 73/116 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31496051, rnn_1_1step_R2_maskV_-1.0=0.67946017, rnn_1_1step_CC_maskV_-1.0=0.82911396, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49073705, val_rnn_1_1step_R2_maskV_-1.0=0.52859443, val_rnn_1_1step_CC_maskV_-1.0=0.73920345, learning_rate=0.001\n", + "Epoch 85/116 - loss=rnn_1_1step_loss=0.28210351, rnn_1_1step_R2_maskV_-1.0=0.7137059, rnn_1_1step_CC_maskV_-1.0=0.84897494, rnn_1_1step_MSE_maskV_-1.0=0.28210348, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47053513, val_rnn_1_1step_R2_maskV_-1.0=0.54873598, val_rnn_1_1step_CC_maskV_-1.0=0.75301027, learning_rate=0.001\n", + "Epoch 97/116 - loss=rnn_1_1step_loss=0.26034936, rnn_1_1step_R2_maskV_-1.0=0.73440731, rnn_1_1step_CC_maskV_-1.0=0.86251646, rnn_1_1step_MSE_maskV_-1.0=0.26034939, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4688758, val_rnn_1_1step_R2_maskV_-1.0=0.55014002, val_rnn_1_1step_CC_maskV_-1.0=0.75627422, learning_rate=0.001\n", + "Epoch 109/116 - loss=rnn_1_1step_loss=0.2394547, rnn_1_1step_R2_maskV_-1.0=0.75614232, rnn_1_1step_CC_maskV_-1.0=0.87377149, rnn_1_1step_MSE_maskV_-1.0=0.23945472, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45294952, val_rnn_1_1step_R2_maskV_-1.0=0.56522751, val_rnn_1_1step_CC_maskV_-1.0=0.76400232, learning_rate=0.001\n", + "Epoch 116/116 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.23298611, rnn_1_1step_R2_maskV_-1.0=0.76233262, rnn_1_1step_CC_maskV_-1.0=0.87750298, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46713006, val_rnn_1_1step_R2_maskV_-1.0=0.55244613, val_rnn_1_1step_CC_maskV_-1.0=0.76002294, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:38:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 13.93s\n", + "\u001b[32m2025-05-30 16:38:59\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.41086459)\n", + "\u001b[32m2025-05-30 16:39:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.183, R2_maskV_-1.0=0.817, CC_maskV_-1.0=0.905\n", + "\u001b[32m2025-05-30 16:39:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.368, R2_maskV_-1.0=0.641, CC_maskV_-1.0=0.809\n", + "\u001b[32m2025-05-30 16:39:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:39:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:39:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 183 (stopped at 198 epochs).\n", + "\u001b[32m2025-05-30 16:39:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/199 - loss=6.6312628, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.01382848, MSE_maskV_-1.0=6.6169028, val_loss=1.6049848, val_CC_maskV_-1.0=0.0090067359, val_MSE_maskV_-1.0=1.5910399, learning_rate=0.001\n", + "Epoch 21/199 - loss=0.89298648, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.32784462, MSE_maskV_-1.0=0.89289892, val_loss=0.9566654, val_CC_maskV_-1.0=0.31233826, val_MSE_maskV_-1.0=0.95246071, learning_rate=0.001\n", + "Epoch 41/199 - loss=0.87259901, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.3574453, MSE_maskV_-1.0=0.87229925, val_loss=0.93908489, val_CC_maskV_-1.0=0.33859047, val_MSE_maskV_-1.0=0.93507659, learning_rate=0.001\n", + "Epoch 61/199 - loss=0.86069888, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37466124, MSE_maskV_-1.0=0.86073506, val_loss=0.92964762, val_CC_maskV_-1.0=0.35229084, val_MSE_maskV_-1.0=0.92569137, learning_rate=0.001\n", + "Epoch 81/199 - loss=0.85223317, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38556513, MSE_maskV_-1.0=0.85215312, val_loss=0.91805702, val_CC_maskV_-1.0=0.36576113, val_MSE_maskV_-1.0=0.91446537, learning_rate=0.001\n", + "Epoch 101/199 - loss=0.84551102, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39482102, MSE_maskV_-1.0=0.84559828, val_loss=0.91583592, val_CC_maskV_-1.0=0.37196791, val_MSE_maskV_-1.0=0.91199082, learning_rate=0.001\n", + "Epoch 121/199 - loss=0.84004289, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40167198, MSE_maskV_-1.0=0.84060031, val_loss=0.9095695, val_CC_maskV_-1.0=0.37718523, val_MSE_maskV_-1.0=0.9060539, learning_rate=0.001\n", + "Epoch 141/199 - loss=0.83572215, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40738249, MSE_maskV_-1.0=0.83568442, val_loss=0.90663266, val_CC_maskV_-1.0=0.38184533, val_MSE_maskV_-1.0=0.90295732, learning_rate=0.001\n", + "Epoch 161/199 - loss=0.83199805, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41092834, MSE_maskV_-1.0=0.83234668, val_loss=0.90108407, val_CC_maskV_-1.0=0.38759997, val_MSE_maskV_-1.0=0.89765531, learning_rate=0.001\n", + "Epoch 181/199 - loss=0.82890773, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41525674, MSE_maskV_-1.0=0.82846344, val_loss=0.89845163, val_CC_maskV_-1.0=0.39133555, val_MSE_maskV_-1.0=0.89507228, learning_rate=0.001\n", + "Epoch 199/199 - loss=0.82613021, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41883144, MSE_maskV_-1.0=0.82542187, val_loss=0.89796901, val_CC_maskV_-1.0=0.39184228, val_MSE_maskV_-1.0=0.89449316, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:39:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 49.47s\n", + "\u001b[32m2025-05-30 16:39:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:40:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 183 (stopped at 198 epochs).\n", + "\u001b[32m2025-05-30 16:40:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/199 - loss=3.1162925, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.019449055, MSE_maskV_-1.0=3.111783, val_loss=1.2396998, val_CC_maskV_-1.0=0.053921849, val_MSE_maskV_-1.0=1.2306769, learning_rate=0.001\n", + "Epoch 21/199 - loss=0.88841653, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.33532062, MSE_maskV_-1.0=0.88832784, val_loss=0.95390421, val_CC_maskV_-1.0=0.31678069, val_MSE_maskV_-1.0=0.94971561, learning_rate=0.001\n", + "Epoch 41/199 - loss=0.86929452, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.36259955, MSE_maskV_-1.0=0.86896962, val_loss=0.93704057, val_CC_maskV_-1.0=0.34115425, val_MSE_maskV_-1.0=0.93314064, learning_rate=0.001\n", + "Epoch 61/199 - loss=0.85853124, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37782648, MSE_maskV_-1.0=0.85856766, val_loss=0.92816043, val_CC_maskV_-1.0=0.35403785, val_MSE_maskV_-1.0=0.92436868, learning_rate=0.001\n", + "Epoch 81/199 - loss=0.85085529, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38740543, MSE_maskV_-1.0=0.85077703, val_loss=0.91688323, val_CC_maskV_-1.0=0.36677688, val_MSE_maskV_-1.0=0.91344959, learning_rate=0.001\n", + "Epoch 101/199 - loss=0.8446629, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39597929, MSE_maskV_-1.0=0.84475923, val_loss=0.91553777, val_CC_maskV_-1.0=0.37184244, val_MSE_maskV_-1.0=0.91184402, learning_rate=0.001\n", + "Epoch 121/199 - loss=0.83962041, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40223476, MSE_maskV_-1.0=0.84016812, val_loss=0.90940487, val_CC_maskV_-1.0=0.37685466, val_MSE_maskV_-1.0=0.9060483, learning_rate=0.001\n", + "Epoch 141/199 - loss=0.83557796, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40758267, MSE_maskV_-1.0=0.83554077, val_loss=0.90689385, val_CC_maskV_-1.0=0.380952, val_MSE_maskV_-1.0=0.90336698, learning_rate=0.001\n", + "Epoch 161/199 - loss=0.83203483, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41085359, MSE_maskV_-1.0=0.83238322, val_loss=0.90130037, val_CC_maskV_-1.0=0.38681236, val_MSE_maskV_-1.0=0.89800817, learning_rate=0.001\n", + "Epoch 181/199 - loss=0.82911855, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41497925, MSE_maskV_-1.0=0.82868534, val_loss=0.89894623, val_CC_maskV_-1.0=0.39023426, val_MSE_maskV_-1.0=0.89568913, learning_rate=0.001\n", + "Epoch 199/199 - loss=0.8264513, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41842404, MSE_maskV_-1.0=0.82573777, val_loss=0.89869905, val_CC_maskV_-1.0=0.39049086, val_MSE_maskV_-1.0=0.89534813, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:40:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 49.56s\n", + "\u001b[32m2025-05-30 16:40:39\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.89414555)\n", + "\u001b[32m2025-05-30 16:40:39\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 795us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:40:40\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.828, R2_maskV_-1.0=0.171, CC_maskV_-1.0=0.417\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 807us/step\n", + "51/51 [==============================] - 0s 725us/step\n", + "84/84 [==============================] - 0s 716us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:40:40\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_KCz1HL64U_ErSV16\" (9/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_KCz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:40:40\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_KCy1HL64U_ErSV16\" (10/16)\n", + "\u001b[32m2025-05-30 16:40:40\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:40:40\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:40:40\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:40:41\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:40:41\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:40:41\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:40:41\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:40:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 89 (stopped at 104 epochs).\n", + "\u001b[32m2025-05-30 16:40:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0058888, rnn_1step_R2_maskV_-1.0=-0.011271976, rnn_1step_CC_maskV_-1.0=0.010006763, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0891366, val_rnn_1step_R2_maskV_-1.0=-0.042023942, val_rnn_1step_CC_maskV_-1.0=0.279937, learning_rate=0.001\n", + "Epoch 12/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.79184318, rnn_1step_R2_maskV_-1.0=0.20282766, rnn_1step_CC_maskV_-1.0=0.48456025, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.84141165, val_rnn_1step_R2_maskV_-1.0=0.1931159, val_rnn_1step_CC_maskV_-1.0=0.48749563, learning_rate=0.001\n", + "Epoch 23/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.54728502, rnn_1step_R2_maskV_-1.0=0.44474396, rnn_1step_CC_maskV_-1.0=0.67424357, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.6543045, val_rnn_1step_R2_maskV_-1.0=0.36898196, val_rnn_1step_CC_maskV_-1.0=0.63213658, learning_rate=0.001\n", + "Epoch 34/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.45329344, rnn_1step_R2_maskV_-1.0=0.53853643, rnn_1step_CC_maskV_-1.0=0.74052161, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.55152977, val_rnn_1step_R2_maskV_-1.0=0.46987557, val_rnn_1step_CC_maskV_-1.0=0.70018268, learning_rate=0.001\n", + "Epoch 45/105 - loss=rnn_1step_loss=0.38106397, rnn_1step_R2_maskV_-1.0=0.61182284, rnn_1step_CC_maskV_-1.0=0.78795832, rnn_1step_MSE_maskV_-1.0=0.381064, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47286639, val_rnn_1step_R2_maskV_-1.0=0.54699004, val_rnn_1step_CC_maskV_-1.0=0.74928892, learning_rate=0.001\n", + "Epoch 56/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31737795, rnn_1step_R2_maskV_-1.0=0.67790443, rnn_1step_CC_maskV_-1.0=0.82743901, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.43616983, val_rnn_1step_R2_maskV_-1.0=0.5822773, val_rnn_1step_CC_maskV_-1.0=0.77137339, learning_rate=0.001\n", + "Epoch 67/105 - loss=rnn_1step_loss=0.27791226, rnn_1step_R2_maskV_-1.0=0.71792722, rnn_1step_CC_maskV_-1.0=0.85081244, rnn_1step_MSE_maskV_-1.0=0.27791223, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42378357, val_rnn_1step_R2_maskV_-1.0=0.59392619, val_rnn_1step_CC_maskV_-1.0=0.77858555, learning_rate=0.001\n", + "Epoch 78/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.25817263, rnn_1step_R2_maskV_-1.0=0.73782277, rnn_1step_CC_maskV_-1.0=0.86227059, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42235827, val_rnn_1step_R2_maskV_-1.0=0.59514928, val_rnn_1step_CC_maskV_-1.0=0.77954447, learning_rate=0.001\n", + "Epoch 89/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.2454534, rnn_1step_R2_maskV_-1.0=0.75060457, rnn_1step_CC_maskV_-1.0=0.86953789, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42102316, val_rnn_1step_R2_maskV_-1.0=0.59640634, val_rnn_1step_CC_maskV_-1.0=0.7806254, learning_rate=0.001\n", + "Epoch 100/105 - loss=rnn_1step_loss=0.23608398, rnn_1step_R2_maskV_-1.0=0.76001221, rnn_1step_CC_maskV_-1.0=0.87483287, rnn_1step_MSE_maskV_-1.0=0.23608397, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42232382, val_rnn_1step_R2_maskV_-1.0=0.59508097, val_rnn_1step_CC_maskV_-1.0=0.78025085, learning_rate=0.001\n", + "Epoch 105/105 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.2324001, rnn_1step_R2_maskV_-1.0=0.76374257, rnn_1step_CC_maskV_-1.0=0.87691242, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42251495, val_rnn_1step_R2_maskV_-1.0=0.59497344, val_rnn_1step_CC_maskV_-1.0=0.78068238, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:40:52\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 11.71s\n", + "\u001b[32m2025-05-30 16:40:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:41:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 100 (stopped at 115 epochs).\n", + "\u001b[32m2025-05-30 16:41:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/116 - loss=rnn_1_1step_loss=1.0055202, rnn_1_1step_R2_maskV_-1.0=-0.010894854, rnn_1_1step_CC_maskV_-1.0=0.075276114, rnn_1_1step_MSE_maskV_-1.0=1.0055203, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0892328, val_rnn_1_1step_R2_maskV_-1.0=-0.042168885, val_rnn_1_1step_CC_maskV_-1.0=0.2840485, learning_rate=0.001\n", + "Epoch 13/116 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.77936333, rnn_1_1step_R2_maskV_-1.0=0.21507815, rnn_1_1step_CC_maskV_-1.0=0.47376585, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.84101957, val_rnn_1_1step_R2_maskV_-1.0=0.19054289, val_rnn_1_1step_CC_maskV_-1.0=0.4825474, learning_rate=0.001\n", + "Epoch 25/116 - loss=rnn_1_1step_loss=0.52908707, rnn_1_1step_R2_maskV_-1.0=0.46266004, rnn_1_1step_CC_maskV_-1.0=0.68715674, rnn_1_1step_MSE_maskV_-1.0=0.52908713, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.63013393, val_rnn_1_1step_R2_maskV_-1.0=0.39512354, val_rnn_1_1step_CC_maskV_-1.0=0.64787519, learning_rate=0.001\n", + "Epoch 37/116 - loss=rnn_1_1step_loss=0.42869839, rnn_1_1step_R2_maskV_-1.0=0.56328666, rnn_1_1step_CC_maskV_-1.0=0.75699234, rnn_1_1step_MSE_maskV_-1.0=0.42869836, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51372558, val_rnn_1_1step_R2_maskV_-1.0=0.5090673, val_rnn_1_1step_CC_maskV_-1.0=0.72404122, learning_rate=0.001\n", + "Epoch 49/116 - loss=rnn_1_1step_loss=0.37717104, rnn_1_1step_R2_maskV_-1.0=0.61533517, rnn_1_1step_CC_maskV_-1.0=0.79025429, rnn_1_1step_MSE_maskV_-1.0=0.37717107, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46977401, val_rnn_1_1step_R2_maskV_-1.0=0.55155975, val_rnn_1_1step_CC_maskV_-1.0=0.75114036, learning_rate=0.001\n", + "Epoch 61/116 - loss=rnn_1_1step_loss=0.33436093, rnn_1_1step_R2_maskV_-1.0=0.65940404, rnn_1_1step_CC_maskV_-1.0=0.81691045, rnn_1_1step_MSE_maskV_-1.0=0.3343609, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45191464, val_rnn_1_1step_R2_maskV_-1.0=0.5683533, val_rnn_1_1step_CC_maskV_-1.0=0.76212013, learning_rate=0.001\n", + "Epoch 73/116 - loss=rnn_1_1step_loss=0.28148463, rnn_1_1step_R2_maskV_-1.0=0.71414137, rnn_1_1step_CC_maskV_-1.0=0.84875721, rnn_1_1step_MSE_maskV_-1.0=0.28148466, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.42756423, val_rnn_1_1step_R2_maskV_-1.0=0.59003133, val_rnn_1_1step_CC_maskV_-1.0=0.77694505, learning_rate=0.001\n", + "Epoch 85/116 - loss=rnn_1_1step_loss=0.25434229, rnn_1_1step_R2_maskV_-1.0=0.74148428, rnn_1_1step_CC_maskV_-1.0=0.8644973, rnn_1_1step_MSE_maskV_-1.0=0.25434226, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41536924, val_rnn_1_1step_R2_maskV_-1.0=0.60096955, val_rnn_1_1step_CC_maskV_-1.0=0.78389287, learning_rate=0.001\n", + "Epoch 97/116 - loss=rnn_1_1step_loss=0.24082653, rnn_1_1step_R2_maskV_-1.0=0.75492918, rnn_1_1step_CC_maskV_-1.0=0.8721298, rnn_1_1step_MSE_maskV_-1.0=0.24082655, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.42140818, val_rnn_1_1step_R2_maskV_-1.0=0.5946238, val_rnn_1_1step_CC_maskV_-1.0=0.78042316, learning_rate=0.001\n", + "Epoch 109/116 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.23089163, rnn_1_1step_R2_maskV_-1.0=0.76477045, rnn_1_1step_CC_maskV_-1.0=0.87793285, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.418607, val_rnn_1_1step_R2_maskV_-1.0=0.59760183, val_rnn_1_1step_CC_maskV_-1.0=0.78179848, learning_rate=0.001\n", + "Epoch 116/116 - loss=rnn_1_1step_loss=0.22229803, rnn_1_1step_R2_maskV_-1.0=0.77362812, rnn_1_1step_CC_maskV_-1.0=0.8827908, rnn_1_1step_MSE_maskV_-1.0=0.22229804, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41484085, val_rnn_1_1step_R2_maskV_-1.0=0.60242581, val_rnn_1_1step_CC_maskV_-1.0=0.78552294, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:41:05\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.75s\n", + "\u001b[32m2025-05-30 16:41:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.40765178)\n", + "\u001b[32m2025-05-30 16:41:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.208, R2_maskV_-1.0=0.792, CC_maskV_-1.0=0.891\n", + "\u001b[32m2025-05-30 16:41:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.372, R2_maskV_-1.0=0.637, CC_maskV_-1.0=0.806\n", + "\u001b[32m2025-05-30 16:41:07\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:41:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:41:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 151 (stopped at 166 epochs).\n", + "\u001b[32m2025-05-30 16:41:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/167 - loss=1.2466917, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.097843975, MSE_maskV_-1.0=1.2472547, val_loss=1.046667, val_CC_maskV_-1.0=0.1508074, val_MSE_maskV_-1.0=1.0407428, learning_rate=0.001\n", + "Epoch 18/167 - loss=0.84632176, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39433885, MSE_maskV_-1.0=0.84629792, val_loss=0.92584658, val_CC_maskV_-1.0=0.35858709, val_MSE_maskV_-1.0=0.92212248, learning_rate=0.001\n", + "Epoch 35/167 - loss=0.80768347, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44149303, MSE_maskV_-1.0=0.80749196, val_loss=0.88884199, val_CC_maskV_-1.0=0.40340596, val_MSE_maskV_-1.0=0.8853423, learning_rate=0.001\n", + "Epoch 52/167 - loss=0.78194898, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46839875, MSE_maskV_-1.0=0.78197598, val_loss=0.86401612, val_CC_maskV_-1.0=0.43106356, val_MSE_maskV_-1.0=0.86074209, learning_rate=0.001\n", + "Epoch 69/167 - loss=0.76794142, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48374623, MSE_maskV_-1.0=0.7678051, val_loss=0.85915196, val_CC_maskV_-1.0=0.43590763, val_MSE_maskV_-1.0=0.85555053, learning_rate=0.001\n", + "Epoch 86/167 - loss=0.75877839, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4926025, MSE_maskV_-1.0=0.75916338, val_loss=0.84557444, val_CC_maskV_-1.0=0.44857129, val_MSE_maskV_-1.0=0.84216249, learning_rate=0.001\n", + "Epoch 103/167 - loss=0.75137192, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50013417, MSE_maskV_-1.0=0.75140554, val_loss=0.84195471, val_CC_maskV_-1.0=0.45018238, val_MSE_maskV_-1.0=0.83931142, learning_rate=0.001\n", + "Epoch 120/167 - loss=0.74559361, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50551099, MSE_maskV_-1.0=0.7450642, val_loss=0.8374086, val_CC_maskV_-1.0=0.45549777, val_MSE_maskV_-1.0=0.83427733, learning_rate=0.001\n", + "Epoch 137/167 - loss=0.74133247, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50938106, MSE_maskV_-1.0=0.74058127, val_loss=0.82469875, val_CC_maskV_-1.0=0.46745613, val_MSE_maskV_-1.0=0.82171124, learning_rate=0.001\n", + "Epoch 154/167 - loss=0.7375651, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51294565, MSE_maskV_-1.0=0.73713762, val_loss=0.82857537, val_CC_maskV_-1.0=0.46335891, val_MSE_maskV_-1.0=0.82543659, learning_rate=0.001\n", + "Epoch 167/167 - loss=0.73595715, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51482391, MSE_maskV_-1.0=0.73554885, val_loss=0.8232469, val_CC_maskV_-1.0=0.46692878, val_MSE_maskV_-1.0=0.82052761, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:41:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 46.15s\n", + "\u001b[32m2025-05-30 16:41:53\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:42:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 189 (stopped at 204 epochs).\n", + "\u001b[32m2025-05-30 16:42:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/205 - loss=1.2035421, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.094046772, MSE_maskV_-1.0=1.2041389, val_loss=1.0417762, val_CC_maskV_-1.0=0.15805162, val_MSE_maskV_-1.0=1.0355334, learning_rate=0.001\n", + "Epoch 22/205 - loss=0.83437395, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40909323, MSE_maskV_-1.0=0.83415288, val_loss=0.91500545, val_CC_maskV_-1.0=0.37267938, val_MSE_maskV_-1.0=0.91137987, learning_rate=0.001\n", + "Epoch 43/205 - loss=0.79121912, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4585157, MSE_maskV_-1.0=0.79037607, val_loss=0.87388277, val_CC_maskV_-1.0=0.41808274, val_MSE_maskV_-1.0=0.87091249, learning_rate=0.001\n", + "Epoch 64/205 - loss=0.77171671, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47935373, MSE_maskV_-1.0=0.77222377, val_loss=0.85600823, val_CC_maskV_-1.0=0.43733144, val_MSE_maskV_-1.0=0.85276186, learning_rate=0.001\n", + "Epoch 85/205 - loss=0.75954938, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49168199, MSE_maskV_-1.0=0.75993735, val_loss=0.84412062, val_CC_maskV_-1.0=0.44786987, val_MSE_maskV_-1.0=0.84119213, learning_rate=0.001\n", + "Epoch 106/205 - loss=0.75120556, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50020957, MSE_maskV_-1.0=0.75097162, val_loss=0.83723933, val_CC_maskV_-1.0=0.45550448, val_MSE_maskV_-1.0=0.83393234, learning_rate=0.001\n", + "Epoch 127/205 - loss=0.74549115, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50542003, MSE_maskV_-1.0=0.74530214, val_loss=0.83186471, val_CC_maskV_-1.0=0.46005508, val_MSE_maskV_-1.0=0.82887322, learning_rate=0.001\n", + "Epoch 148/205 - loss=0.73831093, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51233119, MSE_maskV_-1.0=0.73750204, val_loss=0.83283216, val_CC_maskV_-1.0=0.45846236, val_MSE_maskV_-1.0=0.82978672, learning_rate=0.001\n", + "Epoch 169/205 - loss=0.73730129, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51352561, MSE_maskV_-1.0=0.73785895, val_loss=0.82398975, val_CC_maskV_-1.0=0.46628633, val_MSE_maskV_-1.0=0.8206163, learning_rate=0.001\n", + "Epoch 190/205 - loss=0.73170125, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51854712, MSE_maskV_-1.0=0.73113489, val_loss=0.82045019, val_CC_maskV_-1.0=0.46632901, val_MSE_maskV_-1.0=0.81796598, learning_rate=0.001\n", + "Epoch 205/205 - loss=0.73075825, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51931852, MSE_maskV_-1.0=0.73115122, val_loss=0.81560832, val_CC_maskV_-1.0=0.47324646, val_MSE_maskV_-1.0=0.81227964, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:42:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 53.87s\n", + "\u001b[32m2025-05-30 16:42:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.81170756)\n", + "\u001b[32m2025-05-30 16:42:47\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 851us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:42:47\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.726, R2_maskV_-1.0=0.274, CC_maskV_-1.0=0.525\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 806us/step\n", + "51/51 [==============================] - 0s 857us/step\n", + "84/84 [==============================] - 0s 797us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:42:48\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_KCy1HL64U_ErSV16\" (10/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_KCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:42:48\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_CzCy1HL64U_ErSV16\" (11/16)\n", + "\u001b[32m2025-05-30 16:42:48\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_CzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:42:48\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:42:48\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:42:48\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:42:48\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:42:48\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:42:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:43:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 294 (stopped at 309 epochs).\n", + "\u001b[32m2025-05-30 16:43:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/310 - loss=rnn_1step_loss=1.0056478, rnn_1step_R2_maskV_-1.0=-0.011038415, rnn_1step_CC_maskV_-1.0=0.047704838, rnn_1step_MSE_maskV_-1.0=1.0056479, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0899745, val_rnn_1step_R2_maskV_-1.0=-0.042867944, val_rnn_1step_CC_maskV_-1.0=0.14284609, learning_rate=0.001\n", + "Epoch 32/310 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.55597544, rnn_1step_R2_maskV_-1.0=0.43482476, rnn_1step_CC_maskV_-1.0=0.6684007, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.66532785, val_rnn_1step_R2_maskV_-1.0=0.36007383, val_rnn_1step_CC_maskV_-1.0=0.62680364, learning_rate=0.001\n", + "Epoch 63/310 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.4396731, rnn_1step_R2_maskV_-1.0=0.55216181, rnn_1step_CC_maskV_-1.0=0.74976993, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50195211, val_rnn_1step_R2_maskV_-1.0=0.51882446, val_rnn_1step_CC_maskV_-1.0=0.73286533, learning_rate=0.001\n", + "Epoch 94/310 - loss=rnn_1step_loss=0.4030467, rnn_1step_R2_maskV_-1.0=0.58806491, rnn_1step_CC_maskV_-1.0=0.77390742, rnn_1step_MSE_maskV_-1.0=0.40304667, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45429888, val_rnn_1step_R2_maskV_-1.0=0.56399274, val_rnn_1step_CC_maskV_-1.0=0.76188225, learning_rate=0.001\n", + "Epoch 125/310 - loss=rnn_1step_loss=0.37317935, rnn_1step_R2_maskV_-1.0=0.61839676, rnn_1step_CC_maskV_-1.0=0.79290587, rnn_1step_MSE_maskV_-1.0=0.37317938, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42923912, val_rnn_1step_R2_maskV_-1.0=0.58771563, val_rnn_1step_CC_maskV_-1.0=0.77685785, learning_rate=0.001\n", + "Epoch 156/310 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.34472731, rnn_1step_R2_maskV_-1.0=0.64745539, rnn_1step_CC_maskV_-1.0=0.81068546, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.41414848, val_rnn_1step_R2_maskV_-1.0=0.6025269, val_rnn_1step_CC_maskV_-1.0=0.78568143, learning_rate=0.001\n", + "Epoch 187/310 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33446753, rnn_1step_R2_maskV_-1.0=0.65754181, rnn_1step_CC_maskV_-1.0=0.81696975, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.40818882, val_rnn_1step_R2_maskV_-1.0=0.60851735, val_rnn_1step_CC_maskV_-1.0=0.78908414, learning_rate=0.001\n", + "Epoch 218/310 - loss=rnn_1step_loss=0.32781315, rnn_1step_R2_maskV_-1.0=0.66418725, rnn_1step_CC_maskV_-1.0=0.82094944, rnn_1step_MSE_maskV_-1.0=0.32781312, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.40334377, val_rnn_1step_R2_maskV_-1.0=0.61316472, val_rnn_1step_CC_maskV_-1.0=0.79171556, learning_rate=0.001\n", + "Epoch 249/310 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32312772, rnn_1step_R2_maskV_-1.0=0.66891903, rnn_1step_CC_maskV_-1.0=0.82379776, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.40208355, val_rnn_1step_R2_maskV_-1.0=0.61428654, val_rnn_1step_CC_maskV_-1.0=0.79234523, learning_rate=0.001\n", + "Epoch 280/310 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.3183502, rnn_1step_R2_maskV_-1.0=0.67370915, rnn_1step_CC_maskV_-1.0=0.82669681, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.40074024, val_rnn_1step_R2_maskV_-1.0=0.61552101, val_rnn_1step_CC_maskV_-1.0=0.79294962, learning_rate=0.001\n", + "Epoch 310/310 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31421009, rnn_1step_R2_maskV_-1.0=0.67781413, rnn_1step_CC_maskV_-1.0=0.82920092, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.40017319, val_rnn_1step_R2_maskV_-1.0=0.61596298, val_rnn_1step_CC_maskV_-1.0=0.79318261, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:43:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 30.59s\n", + "\u001b[32m2025-05-30 16:43:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:43:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 286 (stopped at 301 epochs).\n", + "\u001b[32m2025-05-30 16:43:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/302 - loss=rnn_1_1step_loss=1.0049943, rnn_1_1step_R2_maskV_-1.0=-0.010406591, rnn_1_1step_CC_maskV_-1.0=0.11641774, rnn_1_1step_MSE_maskV_-1.0=1.0049942, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0885781, val_rnn_1_1step_R2_maskV_-1.0=-0.041585863, val_rnn_1_1step_CC_maskV_-1.0=0.31170085, learning_rate=0.001\n", + "Epoch 32/302 - loss=rnn_1_1step_loss=0.56528705, rnn_1_1step_R2_maskV_-1.0=0.42779231, rnn_1_1step_CC_maskV_-1.0=0.66150951, rnn_1_1step_MSE_maskV_-1.0=0.56528699, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65517038, val_rnn_1_1step_R2_maskV_-1.0=0.36941224, val_rnn_1_1step_CC_maskV_-1.0=0.63161403, learning_rate=0.001\n", + "Epoch 63/302 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44886473, rnn_1_1step_R2_maskV_-1.0=0.54327142, rnn_1_1step_CC_maskV_-1.0=0.74438214, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49845704, val_rnn_1_1step_R2_maskV_-1.0=0.52160507, val_rnn_1_1step_CC_maskV_-1.0=0.73567277, learning_rate=0.001\n", + "Epoch 94/302 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.40889236, rnn_1_1step_R2_maskV_-1.0=0.5817064, rnn_1_1step_CC_maskV_-1.0=0.77048618, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45529607, val_rnn_1_1step_R2_maskV_-1.0=0.56266987, val_rnn_1_1step_CC_maskV_-1.0=0.76189685, learning_rate=0.001\n", + "Epoch 125/302 - loss=rnn_1_1step_loss=0.38698447, rnn_1_1step_R2_maskV_-1.0=0.60393167, rnn_1_1step_CC_maskV_-1.0=0.78441548, rnn_1_1step_MSE_maskV_-1.0=0.3869845, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.44433895, val_rnn_1_1step_R2_maskV_-1.0=0.57303882, val_rnn_1_1step_CC_maskV_-1.0=0.76843166, learning_rate=0.001\n", + "Epoch 156/302 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36502686, rnn_1_1step_R2_maskV_-1.0=0.62690508, rnn_1_1step_CC_maskV_-1.0=0.79831338, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4339985, val_rnn_1_1step_R2_maskV_-1.0=0.58316219, val_rnn_1_1step_CC_maskV_-1.0=0.7745623, learning_rate=0.001\n", + "Epoch 187/302 - loss=rnn_1_1step_loss=0.34439635, rnn_1_1step_R2_maskV_-1.0=0.64816689, rnn_1_1step_CC_maskV_-1.0=0.81123734, rnn_1_1step_MSE_maskV_-1.0=0.34439641, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.41674456, val_rnn_1_1step_R2_maskV_-1.0=0.60018831, val_rnn_1_1step_CC_maskV_-1.0=0.78415263, learning_rate=0.001\n", + "Epoch 218/302 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33236372, rnn_1_1step_R2_maskV_-1.0=0.66005433, rnn_1_1step_CC_maskV_-1.0=0.81857646, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.40474805, val_rnn_1_1step_R2_maskV_-1.0=0.6117059, val_rnn_1_1step_CC_maskV_-1.0=0.79071164, learning_rate=0.001\n", + "Epoch 249/302 - loss=rnn_1_1step_loss=0.32489869, rnn_1_1step_R2_maskV_-1.0=0.66735613, rnn_1_1step_CC_maskV_-1.0=0.82300603, rnn_1_1step_MSE_maskV_-1.0=0.32489866, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.40144292, val_rnn_1_1step_R2_maskV_-1.0=0.61505252, val_rnn_1_1step_CC_maskV_-1.0=0.79235303, learning_rate=0.001\n", + "Epoch 280/302 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31860653, rnn_1_1step_R2_maskV_-1.0=0.6734705, rnn_1_1step_CC_maskV_-1.0=0.82677668, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.3968769, val_rnn_1_1step_R2_maskV_-1.0=0.6191678, val_rnn_1_1step_CC_maskV_-1.0=0.79476374, learning_rate=0.001\n", + "Epoch 302/302 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31469211, rnn_1_1step_R2_maskV_-1.0=0.67727053, rnn_1_1step_CC_maskV_-1.0=0.82910931, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.39581063, val_rnn_1_1step_R2_maskV_-1.0=0.62009209, val_rnn_1_1step_CC_maskV_-1.0=0.79526067, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:43:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 29.95s\n", + "\u001b[32m2025-05-30 16:43:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.39550781)\n", + "\u001b[32m2025-05-30 16:43:50\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.277, R2_maskV_-1.0=0.723, CC_maskV_-1.0=0.85\n", + "\u001b[32m2025-05-30 16:43:50\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.38, R2_maskV_-1.0=0.626, CC_maskV_-1.0=0.8\n", + "\u001b[32m2025-05-30 16:43:50\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:43:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:44:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 110 (stopped at 125 epochs).\n", + "\u001b[32m2025-05-30 16:44:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/126 - loss=2.3896909, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.032103065, MSE_maskV_-1.0=2.3869901, val_loss=1.194121, val_CC_maskV_-1.0=0.090581417, val_MSE_maskV_-1.0=1.1871063, learning_rate=0.001\n", + "Epoch 14/126 - loss=0.75183427, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49897084, MSE_maskV_-1.0=0.75322711, val_loss=0.82351679, val_CC_maskV_-1.0=0.4656516, val_MSE_maskV_-1.0=0.8203811, learning_rate=0.001\n", + "Epoch 27/126 - loss=0.68951732, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55713493, MSE_maskV_-1.0=0.68966544, val_loss=0.75828147, val_CC_maskV_-1.0=0.52382183, val_MSE_maskV_-1.0=0.75537723, learning_rate=0.001\n", + "Epoch 40/126 - loss=0.66306317, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57978535, MSE_maskV_-1.0=0.66302383, val_loss=0.73848337, val_CC_maskV_-1.0=0.54180008, val_MSE_maskV_-1.0=0.7351135, learning_rate=0.001\n", + "Epoch 53/126 - loss=0.64977592, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59084666, MSE_maskV_-1.0=0.64950031, val_loss=0.72729003, val_CC_maskV_-1.0=0.54942864, val_MSE_maskV_-1.0=0.72398269, learning_rate=0.001\n", + "Epoch 66/126 - loss=0.64097756, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59812558, MSE_maskV_-1.0=0.64064604, val_loss=0.71842289, val_CC_maskV_-1.0=0.55608064, val_MSE_maskV_-1.0=0.71505904, learning_rate=0.001\n", + "Epoch 79/126 - loss=0.63579696, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60200208, MSE_maskV_-1.0=0.63592309, val_loss=0.70904213, val_CC_maskV_-1.0=0.5638352, val_MSE_maskV_-1.0=0.70570058, learning_rate=0.001\n", + "Epoch 92/126 - loss=0.63079679, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60679543, MSE_maskV_-1.0=0.63156372, val_loss=0.71483392, val_CC_maskV_-1.0=0.55807519, val_MSE_maskV_-1.0=0.71157867, learning_rate=0.001\n", + "Epoch 105/126 - loss=0.62890506, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60793102, MSE_maskV_-1.0=0.6285792, val_loss=0.70332563, val_CC_maskV_-1.0=0.56630635, val_MSE_maskV_-1.0=0.700158, learning_rate=0.001\n", + "Epoch 118/126 - loss=0.62508583, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61165571, MSE_maskV_-1.0=0.62491184, val_loss=0.71188521, val_CC_maskV_-1.0=0.5614543, val_MSE_maskV_-1.0=0.70843446, learning_rate=0.001\n", + "Epoch 126/126 - loss=0.6239773, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61241555, MSE_maskV_-1.0=0.62415487, val_loss=0.703538, val_CC_maskV_-1.0=0.56773514, val_MSE_maskV_-1.0=0.70023465, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:44:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 33.84s\n", + "\u001b[32m2025-05-30 16:44:24\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:44:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 94 (stopped at 109 epochs).\n", + "\u001b[32m2025-05-30 16:44:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/110 - loss=3.3935065, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.059187219, MSE_maskV_-1.0=3.3877175, val_loss=1.2213346, val_CC_maskV_-1.0=0.11093276, val_MSE_maskV_-1.0=1.2149248, learning_rate=0.001\n", + "Epoch 12/110 - loss=0.79801279, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44933808, MSE_maskV_-1.0=0.79863501, val_loss=0.87186271, val_CC_maskV_-1.0=0.41780543, val_MSE_maskV_-1.0=0.86886895, learning_rate=0.001\n", + "Epoch 23/110 - loss=0.72836524, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52157497, MSE_maskV_-1.0=0.72761732, val_loss=0.80092651, val_CC_maskV_-1.0=0.48887739, val_MSE_maskV_-1.0=0.79757077, learning_rate=0.001\n", + "Epoch 34/110 - loss=0.69077331, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.55595207, MSE_maskV_-1.0=0.69013083, val_loss=0.76400995, val_CC_maskV_-1.0=0.5219062, val_MSE_maskV_-1.0=0.76042676, learning_rate=0.001\n", + "Epoch 45/110 - loss=0.66994113, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57427371, MSE_maskV_-1.0=0.66941833, val_loss=0.74598384, val_CC_maskV_-1.0=0.53553504, val_MSE_maskV_-1.0=0.74259216, learning_rate=0.001\n", + "Epoch 56/110 - loss=0.65611869, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58597255, MSE_maskV_-1.0=0.65591991, val_loss=0.72945833, val_CC_maskV_-1.0=0.54940879, val_MSE_maskV_-1.0=0.72572476, learning_rate=0.001\n", + "Epoch 67/110 - loss=0.64809519, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59243411, MSE_maskV_-1.0=0.6484555, val_loss=0.72315502, val_CC_maskV_-1.0=0.55330724, val_MSE_maskV_-1.0=0.71963286, learning_rate=0.001\n", + "Epoch 78/110 - loss=0.64362556, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59595054, MSE_maskV_-1.0=0.64350927, val_loss=0.72248763, val_CC_maskV_-1.0=0.55507922, val_MSE_maskV_-1.0=0.7189486, learning_rate=0.001\n", + "Epoch 89/110 - loss=0.63814169, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60065281, MSE_maskV_-1.0=0.63824564, val_loss=0.71665883, val_CC_maskV_-1.0=0.55823106, val_MSE_maskV_-1.0=0.71334434, learning_rate=0.001\n", + "Epoch 100/110 - loss=0.63448298, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60343683, MSE_maskV_-1.0=0.63478094, val_loss=0.70844001, val_CC_maskV_-1.0=0.56287241, val_MSE_maskV_-1.0=0.70535505, learning_rate=0.001\n", + "Epoch 110/110 - loss=0.62969929, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6074577, MSE_maskV_-1.0=0.62957782, val_loss=0.7061125, val_CC_maskV_-1.0=0.56501794, val_MSE_maskV_-1.0=0.7029292, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:44:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 30.43s\n", + "\u001b[32m2025-05-30 16:44:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.6993565)\n", + "\u001b[32m2025-05-30 16:44:55\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 842us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:44:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.62, R2_maskV_-1.0=0.38, CC_maskV_-1.0=0.617\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 878us/step\n", + "51/51 [==============================] - 0s 809us/step\n", + "84/84 [==============================] - 0s 736us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:44:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_CzCy1HL64U_ErSV16\" (11/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_CzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:44:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_uAKCz1HL64U_ErSV16\" (12/16)\n", + "\u001b[32m2025-05-30 16:44:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCz1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:44:56\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:44:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:44:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:44:56\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:44:56\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:44:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:45:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 100 (stopped at 115 epochs).\n", + "\u001b[32m2025-05-30 16:45:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/116 - loss=rnn_1step_loss=1.0058478, rnn_1step_R2_maskV_-1.0=-0.011275336, rnn_1step_CC_maskV_-1.0=0.053919651, rnn_1step_MSE_maskV_-1.0=1.0058477, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0907199, val_rnn_1step_R2_maskV_-1.0=-0.043569177, val_rnn_1step_CC_maskV_-1.0=0.20068847, learning_rate=0.001\n", + "Epoch 13/116 - loss=rnn_1step_loss=0.82336044, rnn_1step_R2_maskV_-1.0=0.16624421, rnn_1step_CC_maskV_-1.0=0.42909521, rnn_1step_MSE_maskV_-1.0=0.8233605, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.92134994, val_rnn_1step_R2_maskV_-1.0=0.11758739, val_rnn_1step_CC_maskV_-1.0=0.40996358, learning_rate=0.001\n", + "Epoch 25/116 - loss=rnn_1step_loss=0.6379258, rnn_1step_R2_maskV_-1.0=0.35191929, rnn_1step_CC_maskV_-1.0=0.6042586, rnn_1step_MSE_maskV_-1.0=0.63792574, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.77309418, val_rnn_1step_R2_maskV_-1.0=0.2531397, val_rnn_1step_CC_maskV_-1.0=0.54195571, learning_rate=0.001\n", + "Epoch 37/116 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.54527116, rnn_1step_R2_maskV_-1.0=0.44450837, rnn_1step_CC_maskV_-1.0=0.67621231, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.69914341, val_rnn_1step_R2_maskV_-1.0=0.32486439, val_rnn_1step_CC_maskV_-1.0=0.59747219, learning_rate=0.001\n", + "Epoch 49/116 - loss=rnn_1step_loss=0.4813385, rnn_1step_R2_maskV_-1.0=0.50818396, rnn_1step_CC_maskV_-1.0=0.72129464, rnn_1step_MSE_maskV_-1.0=0.48133847, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.64349526, val_rnn_1step_R2_maskV_-1.0=0.38150501, val_rnn_1step_CC_maskV_-1.0=0.63680542, learning_rate=0.001\n", + "Epoch 61/116 - loss=rnn_1step_loss=0.42503259, rnn_1step_R2_maskV_-1.0=0.56451142, rnn_1step_CC_maskV_-1.0=0.75934571, rnn_1step_MSE_maskV_-1.0=0.42503256, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.58771271, val_rnn_1step_R2_maskV_-1.0=0.43639165, val_rnn_1step_CC_maskV_-1.0=0.67578077, learning_rate=0.001\n", + "Epoch 73/116 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.37358031, rnn_1step_R2_maskV_-1.0=0.6160447, rnn_1step_CC_maskV_-1.0=0.79296637, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.53394204, val_rnn_1step_R2_maskV_-1.0=0.48882779, val_rnn_1step_CC_maskV_-1.0=0.71000695, learning_rate=0.001\n", + "Epoch 85/116 - loss=rnn_1step_loss=0.33531368, rnn_1step_R2_maskV_-1.0=0.65479791, rnn_1step_CC_maskV_-1.0=0.81627154, rnn_1step_MSE_maskV_-1.0=0.33531365, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.52653325, val_rnn_1step_R2_maskV_-1.0=0.49535638, val_rnn_1step_CC_maskV_-1.0=0.71528167, learning_rate=0.001\n", + "Epoch 97/116 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30919448, rnn_1step_R2_maskV_-1.0=0.68189365, rnn_1step_CC_maskV_-1.0=0.83239049, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5126726, val_rnn_1step_R2_maskV_-1.0=0.508452, val_rnn_1step_CC_maskV_-1.0=0.72542119, learning_rate=0.001\n", + "Epoch 109/116 - loss=rnn_1step_loss=0.28892866, rnn_1step_R2_maskV_-1.0=0.70231688, rnn_1step_CC_maskV_-1.0=0.84416854, rnn_1step_MSE_maskV_-1.0=0.28892869, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51829922, val_rnn_1step_R2_maskV_-1.0=0.50267684, val_rnn_1step_CC_maskV_-1.0=0.72268057, learning_rate=0.001\n", + "Epoch 116/116 - loss=rnn_1step_loss=0.27848056, rnn_1step_R2_maskV_-1.0=0.71342272, rnn_1step_CC_maskV_-1.0=0.85016131, rnn_1step_MSE_maskV_-1.0=0.27848059, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5217104, val_rnn_1step_R2_maskV_-1.0=0.49869242, val_rnn_1step_CC_maskV_-1.0=0.72066629, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:45:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.86s\n", + "\u001b[32m2025-05-30 16:45:11\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:45:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 178 (stopped at 193 epochs).\n", + "\u001b[32m2025-05-30 16:45:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/194 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0059414, rnn_1_1step_R2_maskV_-1.0=-0.011373222, rnn_1_1step_CC_maskV_-1.0=0.0085157398, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0908828, val_rnn_1_1step_R2_maskV_-1.0=-0.043726236, val_rnn_1_1step_CC_maskV_-1.0=0.15443762, learning_rate=0.001\n", + "Epoch 21/194 - loss=rnn_1_1step_loss=0.65048116, rnn_1_1step_R2_maskV_-1.0=0.33735061, rnn_1_1step_CC_maskV_-1.0=0.59581351, rnn_1_1step_MSE_maskV_-1.0=0.6504811, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.78846055, val_rnn_1_1step_R2_maskV_-1.0=0.24395545, val_rnn_1_1step_CC_maskV_-1.0=0.53698403, learning_rate=0.001\n", + "Epoch 41/194 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.5330798, rnn_1_1step_R2_maskV_-1.0=0.45661092, rnn_1_1step_CC_maskV_-1.0=0.68595737, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.70463711, val_rnn_1_1step_R2_maskV_-1.0=0.3242051, val_rnn_1_1step_CC_maskV_-1.0=0.59271628, learning_rate=0.001\n", + "Epoch 61/194 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.42698267, rnn_1_1step_R2_maskV_-1.0=0.56295359, rnn_1_1step_CC_maskV_-1.0=0.75865811, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.61012608, val_rnn_1_1step_R2_maskV_-1.0=0.41417864, val_rnn_1_1step_CC_maskV_-1.0=0.66215467, learning_rate=0.001\n", + "Epoch 81/194 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.3543756, rnn_1_1step_R2_maskV_-1.0=0.63683701, rnn_1_1step_CC_maskV_-1.0=0.80521315, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56325036, val_rnn_1_1step_R2_maskV_-1.0=0.45996299, val_rnn_1_1step_CC_maskV_-1.0=0.69617301, learning_rate=0.001\n", + "Epoch 101/194 - loss=rnn_1_1step_loss=0.30694255, rnn_1_1step_R2_maskV_-1.0=0.68491256, rnn_1_1step_CC_maskV_-1.0=0.83330399, rnn_1_1step_MSE_maskV_-1.0=0.30694252, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5172506, val_rnn_1_1step_R2_maskV_-1.0=0.5047164, val_rnn_1_1step_CC_maskV_-1.0=0.72586614, learning_rate=0.001\n", + "Epoch 121/194 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.282693, rnn_1_1step_R2_maskV_-1.0=0.71029848, rnn_1_1step_CC_maskV_-1.0=0.84827787, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.5047527, val_rnn_1_1step_R2_maskV_-1.0=0.51745856, val_rnn_1_1step_CC_maskV_-1.0=0.73439807, learning_rate=0.001\n", + "Epoch 141/194 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.26333034, rnn_1_1step_R2_maskV_-1.0=0.72983015, rnn_1_1step_CC_maskV_-1.0=0.85976243, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.50724167, val_rnn_1_1step_R2_maskV_-1.0=0.51495445, val_rnn_1_1step_CC_maskV_-1.0=0.7359159, learning_rate=0.001\n", + "Epoch 161/194 - loss=rnn_1_1step_loss=0.23510528, rnn_1_1step_R2_maskV_-1.0=0.75927961, rnn_1_1step_CC_maskV_-1.0=0.87552834, rnn_1_1step_MSE_maskV_-1.0=0.23510529, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49435234, val_rnn_1_1step_R2_maskV_-1.0=0.52655292, val_rnn_1_1step_CC_maskV_-1.0=0.74339026, learning_rate=0.001\n", + "Epoch 181/194 - loss=rnn_1_1step_loss=0.21509866, rnn_1_1step_R2_maskV_-1.0=0.77966505, rnn_1_1step_CC_maskV_-1.0=0.88688231, rnn_1_1step_MSE_maskV_-1.0=0.21509868, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47275653, val_rnn_1_1step_R2_maskV_-1.0=0.54753911, val_rnn_1_1step_CC_maskV_-1.0=0.754498, learning_rate=0.001\n", + "Epoch 194/194 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.20309268, rnn_1_1step_R2_maskV_-1.0=0.79248703, rnn_1_1step_CC_maskV_-1.0=0.89451146, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49585643, val_rnn_1_1step_R2_maskV_-1.0=0.52503097, val_rnn_1_1step_CC_maskV_-1.0=0.74120575, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:45:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 22.76s\n", + "\u001b[32m2025-05-30 16:45:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.46398368)\n", + "\u001b[32m2025-05-30 16:45:35\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.206, R2_maskV_-1.0=0.794, CC_maskV_-1.0=0.892\n", + "\u001b[32m2025-05-30 16:45:35\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.434, R2_maskV_-1.0=0.575, CC_maskV_-1.0=0.771\n", + "\u001b[32m2025-05-30 16:45:35\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:45:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:46:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 217 (stopped at 232 epochs).\n", + "\u001b[32m2025-05-30 16:46:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/233 - loss=1.9028637, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.055997629, MSE_maskV_-1.0=1.9020526, val_loss=1.1505309, val_CC_maskV_-1.0=0.093601562, val_MSE_maskV_-1.0=1.142972, learning_rate=0.001\n", + "Epoch 25/233 - loss=0.88192445, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34644923, MSE_maskV_-1.0=0.88145256, val_loss=0.95032752, val_CC_maskV_-1.0=0.32653385, val_MSE_maskV_-1.0=0.94560242, learning_rate=0.001\n", + "Epoch 49/233 - loss=0.85852593, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.37932295, MSE_maskV_-1.0=0.85820693, val_loss=0.92213368, val_CC_maskV_-1.0=0.3648999, val_MSE_maskV_-1.0=0.91819143, learning_rate=0.001\n", + "Epoch 73/233 - loss=0.84629518, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39545283, MSE_maskV_-1.0=0.84599084, val_loss=0.91174227, val_CC_maskV_-1.0=0.37702218, val_MSE_maskV_-1.0=0.90797544, learning_rate=0.001\n", + "Epoch 97/233 - loss=0.83755511, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40587932, MSE_maskV_-1.0=0.83768106, val_loss=0.90120578, val_CC_maskV_-1.0=0.38822579, val_MSE_maskV_-1.0=0.8974694, learning_rate=0.001\n", + "Epoch 121/233 - loss=0.83192348, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4125624, MSE_maskV_-1.0=0.83237004, val_loss=0.89559996, val_CC_maskV_-1.0=0.39539719, val_MSE_maskV_-1.0=0.891909, learning_rate=0.001\n", + "Epoch 145/233 - loss=0.82780564, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41673723, MSE_maskV_-1.0=0.82775772, val_loss=0.89263332, val_CC_maskV_-1.0=0.39732024, val_MSE_maskV_-1.0=0.88930988, learning_rate=0.001\n", + "Epoch 169/233 - loss=0.82436049, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42068854, MSE_maskV_-1.0=0.82498318, val_loss=0.88849074, val_CC_maskV_-1.0=0.40150163, val_MSE_maskV_-1.0=0.88515419, learning_rate=0.001\n", + "Epoch 193/233 - loss=0.82175219, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42371827, MSE_maskV_-1.0=0.82116801, val_loss=0.88652539, val_CC_maskV_-1.0=0.40498951, val_MSE_maskV_-1.0=0.88302034, learning_rate=0.001\n", + "Epoch 217/233 - loss=0.81966043, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42677474, MSE_maskV_-1.0=0.82028401, val_loss=0.88013846, val_CC_maskV_-1.0=0.4113479, val_MSE_maskV_-1.0=0.8767525, learning_rate=0.001\n", + "Epoch 233/233 - loss=0.81830239, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42741755, MSE_maskV_-1.0=0.81776571, val_loss=0.88155395, val_CC_maskV_-1.0=0.41036552, val_MSE_maskV_-1.0=0.87814486, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:46:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 57.46s\n", + "\u001b[32m2025-05-30 16:46:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:47:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 217 (stopped at 232 epochs).\n", + "\u001b[32m2025-05-30 16:47:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/233 - loss=1.8550699, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.014589528, MSE_maskV_-1.0=1.8543265, val_loss=1.1678748, val_CC_maskV_-1.0=0.076370254, val_MSE_maskV_-1.0=1.1633859, learning_rate=0.001\n", + "Epoch 25/233 - loss=0.88041234, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.34854582, MSE_maskV_-1.0=0.8799125, val_loss=0.94602299, val_CC_maskV_-1.0=0.33274183, val_MSE_maskV_-1.0=0.94154799, learning_rate=0.001\n", + "Epoch 49/233 - loss=0.85735625, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.38088897, MSE_maskV_-1.0=0.85702008, val_loss=0.91937596, val_CC_maskV_-1.0=0.36851078, val_MSE_maskV_-1.0=0.91563421, learning_rate=0.001\n", + "Epoch 73/233 - loss=0.84538323, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39654911, MSE_maskV_-1.0=0.84507704, val_loss=0.90963697, val_CC_maskV_-1.0=0.37956646, val_MSE_maskV_-1.0=0.90602821, learning_rate=0.001\n", + "Epoch 97/233 - loss=0.83684576, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40671095, MSE_maskV_-1.0=0.83698893, val_loss=0.8996675, val_CC_maskV_-1.0=0.3898232, val_MSE_maskV_-1.0=0.89608294, learning_rate=0.001\n", + "Epoch 121/233 - loss=0.83133906, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41324016, MSE_maskV_-1.0=0.83178777, val_loss=0.89425164, val_CC_maskV_-1.0=0.39684629, val_MSE_maskV_-1.0=0.89068067, learning_rate=0.001\n", + "Epoch 145/233 - loss=0.82731074, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41728756, MSE_maskV_-1.0=0.82726228, val_loss=0.8915298, val_CC_maskV_-1.0=0.39845538, val_MSE_maskV_-1.0=0.88831997, learning_rate=0.001\n", + "Epoch 169/233 - loss=0.82393062, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42116079, MSE_maskV_-1.0=0.82455975, val_loss=0.88759232, val_CC_maskV_-1.0=0.40236825, val_MSE_maskV_-1.0=0.88434863, learning_rate=0.001\n", + "Epoch 193/233 - loss=0.82137579, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42412078, MSE_maskV_-1.0=0.82079583, val_loss=0.88571572, val_CC_maskV_-1.0=0.4057664, val_MSE_maskV_-1.0=0.88230109, learning_rate=0.001\n", + "Epoch 217/233 - loss=0.81933558, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42713445, MSE_maskV_-1.0=0.81994963, val_loss=0.87964165, val_CC_maskV_-1.0=0.41177586, val_MSE_maskV_-1.0=0.87632698, learning_rate=0.001\n", + "Epoch 233/233 - loss=0.81799269, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.42776763, MSE_maskV_-1.0=0.81746221, val_loss=0.88112515, val_CC_maskV_-1.0=0.41073579, val_MSE_maskV_-1.0=0.87778378, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:47:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 56.54s\n", + "\u001b[32m2025-05-30 16:47:29\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.87964165)\n", + "\u001b[32m2025-05-30 16:47:29\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 755us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:47:30\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.819, R2_maskV_-1.0=0.18, CC_maskV_-1.0=0.428\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 774us/step\n", + "51/51 [==============================] - 0s 771us/step\n", + "84/84 [==============================] - 0s 740us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:47:30\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_uAKCz1HL64U_ErSV16\" (12/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_uAKCz1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:47:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_uAKCy1HL64U_ErSV16\" (13/16)\n", + "\u001b[32m2025-05-30 16:47:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:47:31\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:47:31\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:47:31\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:47:31\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:47:31\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:47:31\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:47:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 77 (stopped at 92 epochs).\n", + "\u001b[32m2025-05-30 16:47:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/93 - loss=rnn_1step_loss=1.0056115, rnn_1step_R2_maskV_-1.0=-0.010992974, rnn_1step_CC_maskV_-1.0=0.042368773, rnn_1step_MSE_maskV_-1.0=1.0056117, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0886716, val_rnn_1step_R2_maskV_-1.0=-0.041612536, val_rnn_1step_CC_maskV_-1.0=0.27322647, learning_rate=0.001\n", + "Epoch 11/93 - loss=rnn_1step_loss=0.84785366, rnn_1step_R2_maskV_-1.0=0.15109545, rnn_1step_CC_maskV_-1.0=0.39853427, rnn_1step_MSE_maskV_-1.0=0.84785372, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.90331507, val_rnn_1step_R2_maskV_-1.0=0.12827256, val_rnn_1step_CC_maskV_-1.0=0.42487764, learning_rate=0.001\n", + "Epoch 21/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.63414246, rnn_1step_R2_maskV_-1.0=0.35790372, rnn_1step_CC_maskV_-1.0=0.60776609, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.72797686, val_rnn_1step_R2_maskV_-1.0=0.292391, val_rnn_1step_CC_maskV_-1.0=0.58490735, learning_rate=0.001\n", + "Epoch 31/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.52744275, rnn_1step_R2_maskV_-1.0=0.46239299, rnn_1step_CC_maskV_-1.0=0.68930519, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.66162795, val_rnn_1step_R2_maskV_-1.0=0.35979664, val_rnn_1step_CC_maskV_-1.0=0.63266385, learning_rate=0.001\n", + "Epoch 41/93 - loss=rnn_1step_loss=0.43438134, rnn_1step_R2_maskV_-1.0=0.55589879, rnn_1step_CC_maskV_-1.0=0.75310731, rnn_1step_MSE_maskV_-1.0=0.43438131, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57732993, val_rnn_1step_R2_maskV_-1.0=0.44350505, val_rnn_1step_CC_maskV_-1.0=0.68556321, learning_rate=0.001\n", + "Epoch 51/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35241425, rnn_1step_R2_maskV_-1.0=0.63870668, rnn_1step_CC_maskV_-1.0=0.80589533, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.4975346, val_rnn_1step_R2_maskV_-1.0=0.52172136, val_rnn_1step_CC_maskV_-1.0=0.73390412, learning_rate=0.001\n", + "Epoch 61/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31409851, rnn_1step_R2_maskV_-1.0=0.67737508, rnn_1step_CC_maskV_-1.0=0.82979828, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46731076, val_rnn_1step_R2_maskV_-1.0=0.55071664, val_rnn_1step_CC_maskV_-1.0=0.75511116, learning_rate=0.001\n", + "Epoch 71/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.27959111, rnn_1step_R2_maskV_-1.0=0.7132085, rnn_1step_CC_maskV_-1.0=0.8496778, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45454898, val_rnn_1step_R2_maskV_-1.0=0.56308138, val_rnn_1step_CC_maskV_-1.0=0.76205897, learning_rate=0.001\n", + "Epoch 81/93 - loss=rnn_1step_loss=0.25762674, rnn_1step_R2_maskV_-1.0=0.73592943, rnn_1step_CC_maskV_-1.0=0.86248559, rnn_1step_MSE_maskV_-1.0=0.25762671, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45362511, val_rnn_1step_R2_maskV_-1.0=0.5639317, val_rnn_1step_CC_maskV_-1.0=0.76243925, learning_rate=0.001\n", + "Epoch 91/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.2330941, rnn_1step_R2_maskV_-1.0=0.76083577, rnn_1step_CC_maskV_-1.0=0.8766911, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45482066, val_rnn_1step_R2_maskV_-1.0=0.56216991, val_rnn_1step_CC_maskV_-1.0=0.76441312, learning_rate=0.001\n", + "Epoch 93/93 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.23555511, rnn_1step_R2_maskV_-1.0=0.75876939, rnn_1step_CC_maskV_-1.0=0.87580436, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45595905, val_rnn_1step_R2_maskV_-1.0=0.56089813, val_rnn_1step_CC_maskV_-1.0=0.76319444, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:47:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 11.78s\n", + "\u001b[32m2025-05-30 16:47:43\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:47:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 80 (stopped at 95 epochs).\n", + "\u001b[32m2025-05-30 16:47:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/96 - loss=rnn_1_1step_loss=1.0052942, rnn_1_1step_R2_maskV_-1.0=-0.010684442, rnn_1_1step_CC_maskV_-1.0=0.095173076, rnn_1_1step_MSE_maskV_-1.0=1.0052941, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.08956, val_rnn_1_1step_R2_maskV_-1.0=-0.042549282, val_rnn_1_1step_CC_maskV_-1.0=0.21464264, learning_rate=0.001\n", + "Epoch 11/96 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.81562501, rnn_1_1step_R2_maskV_-1.0=0.18078372, rnn_1_1step_CC_maskV_-1.0=0.51293927, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.86674088, val_rnn_1_1step_R2_maskV_-1.0=0.16717543, val_rnn_1_1step_CC_maskV_-1.0=0.49070498, learning_rate=0.001\n", + "Epoch 21/96 - loss=rnn_1_1step_loss=0.58061552, rnn_1_1step_R2_maskV_-1.0=0.41059959, rnn_1_1step_CC_maskV_-1.0=0.6503489, rnn_1_1step_MSE_maskV_-1.0=0.58061546, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.69647962, val_rnn_1_1step_R2_maskV_-1.0=0.32503384, val_rnn_1_1step_CC_maskV_-1.0=0.60614383, learning_rate=0.001\n", + "Epoch 31/96 - loss=rnn_1_1step_loss=0.47019473, rnn_1_1step_R2_maskV_-1.0=0.52037966, rnn_1_1step_CC_maskV_-1.0=0.72926629, rnn_1_1step_MSE_maskV_-1.0=0.47019476, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59849817, val_rnn_1_1step_R2_maskV_-1.0=0.42159468, val_rnn_1_1step_CC_maskV_-1.0=0.67182446, learning_rate=0.001\n", + "Epoch 41/96 - loss=rnn_1_1step_loss=0.37891293, rnn_1_1step_R2_maskV_-1.0=0.61319274, rnn_1_1step_CC_maskV_-1.0=0.78930724, rnn_1_1step_MSE_maskV_-1.0=0.37891296, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.51639032, val_rnn_1_1step_R2_maskV_-1.0=0.50294155, val_rnn_1_1step_CC_maskV_-1.0=0.72347438, learning_rate=0.001\n", + "Epoch 51/96 - loss=rnn_1_1step_loss=0.32248273, rnn_1_1step_R2_maskV_-1.0=0.67042434, rnn_1_1step_CC_maskV_-1.0=0.82426888, rnn_1_1step_MSE_maskV_-1.0=0.32248276, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47275558, val_rnn_1_1step_R2_maskV_-1.0=0.54626763, val_rnn_1_1step_CC_maskV_-1.0=0.75016767, learning_rate=0.001\n", + "Epoch 61/96 - loss=rnn_1_1step_loss=0.29114637, rnn_1_1step_R2_maskV_-1.0=0.70210683, rnn_1_1step_CC_maskV_-1.0=0.84379166, rnn_1_1step_MSE_maskV_-1.0=0.29114634, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45721063, val_rnn_1_1step_R2_maskV_-1.0=0.56048286, val_rnn_1_1step_CC_maskV_-1.0=0.76019126, learning_rate=0.001\n", + "Epoch 71/96 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.25886422, rnn_1_1step_R2_maskV_-1.0=0.73506939, rnn_1_1step_CC_maskV_-1.0=0.86212695, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45716366, val_rnn_1_1step_R2_maskV_-1.0=0.56022781, val_rnn_1_1step_CC_maskV_-1.0=0.76111972, learning_rate=0.001\n", + "Epoch 81/96 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.24318343, rnn_1_1step_R2_maskV_-1.0=0.75110346, rnn_1_1step_CC_maskV_-1.0=0.8709358, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45638356, val_rnn_1_1step_R2_maskV_-1.0=0.56074399, val_rnn_1_1step_CC_maskV_-1.0=0.7624141, learning_rate=0.001\n", + "Epoch 91/96 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.23344576, rnn_1_1step_R2_maskV_-1.0=0.76094961, rnn_1_1step_CC_maskV_-1.0=0.87638724, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45942339, val_rnn_1_1step_R2_maskV_-1.0=0.55764395, val_rnn_1_1step_CC_maskV_-1.0=0.76034695, learning_rate=0.001\n", + "Epoch 96/96 - loss=rnn_1_1step_loss=0.22875766, rnn_1_1step_R2_maskV_-1.0=0.7655772, rnn_1_1step_CC_maskV_-1.0=0.87910742, rnn_1_1step_MSE_maskV_-1.0=0.22875768, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45519876, val_rnn_1_1step_R2_maskV_-1.0=0.56172115, val_rnn_1_1step_CC_maskV_-1.0=0.76400304, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:47:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 12.12s\n", + "\u001b[32m2025-05-30 16:47:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.44957289)\n", + "\u001b[32m2025-05-30 16:47:56\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.219, R2_maskV_-1.0=0.781, CC_maskV_-1.0=0.883\n", + "\u001b[32m2025-05-30 16:47:57\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.423, R2_maskV_-1.0=0.585, CC_maskV_-1.0=0.777\n", + "\u001b[32m2025-05-30 16:47:57\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:47:57\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:48:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 177 (stopped at 192 epochs).\n", + "\u001b[32m2025-05-30 16:48:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/193 - loss=1.0571463, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.14585598, MSE_maskV_-1.0=1.0582825, val_loss=1.014966, val_CC_maskV_-1.0=0.21832629, val_MSE_maskV_-1.0=1.0089921, learning_rate=0.001\n", + "Epoch 21/193 - loss=0.82742804, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41719377, MSE_maskV_-1.0=0.82726777, val_loss=0.90791422, val_CC_maskV_-1.0=0.3759152, val_MSE_maskV_-1.0=0.90448636, learning_rate=0.001\n", + "Epoch 41/193 - loss=0.79375106, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45476019, MSE_maskV_-1.0=0.7934314, val_loss=0.87846315, val_CC_maskV_-1.0=0.40697631, val_MSE_maskV_-1.0=0.87531453, learning_rate=0.001\n", + "Epoch 61/193 - loss=0.77579117, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47391883, MSE_maskV_-1.0=0.77571476, val_loss=0.86488873, val_CC_maskV_-1.0=0.42102054, val_MSE_maskV_-1.0=0.86247849, learning_rate=0.001\n", + "Epoch 81/193 - loss=0.76483005, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48466992, MSE_maskV_-1.0=0.76489943, val_loss=0.85523927, val_CC_maskV_-1.0=0.43016049, val_MSE_maskV_-1.0=0.85288411, learning_rate=0.001\n", + "Epoch 101/193 - loss=0.75713146, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49259555, MSE_maskV_-1.0=0.75742596, val_loss=0.84979719, val_CC_maskV_-1.0=0.43641827, val_MSE_maskV_-1.0=0.84792084, learning_rate=0.001\n", + "Epoch 121/193 - loss=0.75000685, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50028306, MSE_maskV_-1.0=0.75045532, val_loss=0.84902024, val_CC_maskV_-1.0=0.43743041, val_MSE_maskV_-1.0=0.84697926, learning_rate=0.001\n", + "Epoch 141/193 - loss=0.74616373, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50430512, MSE_maskV_-1.0=0.74607629, val_loss=0.84390181, val_CC_maskV_-1.0=0.44167504, val_MSE_maskV_-1.0=0.84214365, learning_rate=0.001\n", + "Epoch 161/193 - loss=0.74200153, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50729287, MSE_maskV_-1.0=0.74218768, val_loss=0.84337473, val_CC_maskV_-1.0=0.4409765, val_MSE_maskV_-1.0=0.8418749, learning_rate=0.001\n", + "Epoch 181/193 - loss=0.73781198, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51171976, MSE_maskV_-1.0=0.73763156, val_loss=0.83953273, val_CC_maskV_-1.0=0.44679886, val_MSE_maskV_-1.0=0.8378157, learning_rate=0.001\n", + "Epoch 193/193 - loss=0.7363624, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51295567, MSE_maskV_-1.0=0.73587573, val_loss=0.84266847, val_CC_maskV_-1.0=0.44501215, val_MSE_maskV_-1.0=0.84096354, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:48:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 52.50s\n", + "\u001b[32m2025-05-30 16:48:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:49:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 151 (stopped at 166 epochs).\n", + "\u001b[32m2025-05-30 16:49:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/167 - loss=1.0533139, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.16054332, MSE_maskV_-1.0=1.0543805, val_loss=1.0127598, val_CC_maskV_-1.0=0.22034584, val_MSE_maskV_-1.0=1.0072745, learning_rate=0.001\n", + "Epoch 18/167 - loss=0.83911079, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.40350646, MSE_maskV_-1.0=0.83906865, val_loss=0.92024446, val_CC_maskV_-1.0=0.3623358, val_MSE_maskV_-1.0=0.91679353, learning_rate=0.001\n", + "Epoch 35/167 - loss=0.80226773, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.44642094, MSE_maskV_-1.0=0.80203056, val_loss=0.8907963, val_CC_maskV_-1.0=0.39606845, val_MSE_maskV_-1.0=0.88731539, learning_rate=0.001\n", + "Epoch 52/167 - loss=0.78190774, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46726209, MSE_maskV_-1.0=0.78190893, val_loss=0.87269753, val_CC_maskV_-1.0=0.41591811, val_MSE_maskV_-1.0=0.86941236, learning_rate=0.001\n", + "Epoch 69/167 - loss=0.77063572, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48003194, MSE_maskV_-1.0=0.77048475, val_loss=0.86511415, val_CC_maskV_-1.0=0.42366561, val_MSE_maskV_-1.0=0.86184013, learning_rate=0.001\n", + "Epoch 86/167 - loss=0.76111215, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48875579, MSE_maskV_-1.0=0.76151454, val_loss=0.85651988, val_CC_maskV_-1.0=0.43349561, val_MSE_maskV_-1.0=0.8535825, learning_rate=0.001\n", + "Epoch 103/167 - loss=0.75560105, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49510661, MSE_maskV_-1.0=0.75564039, val_loss=0.85184515, val_CC_maskV_-1.0=0.43725759, val_MSE_maskV_-1.0=0.84886318, learning_rate=0.001\n", + "Epoch 120/167 - loss=0.74968678, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4999724, MSE_maskV_-1.0=0.74939805, val_loss=0.8486799, val_CC_maskV_-1.0=0.44160172, val_MSE_maskV_-1.0=0.84527493, learning_rate=0.001\n", + "Epoch 137/167 - loss=0.74584448, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50351793, MSE_maskV_-1.0=0.74509507, val_loss=0.84194648, val_CC_maskV_-1.0=0.44688705, val_MSE_maskV_-1.0=0.83893579, learning_rate=0.001\n", + "Epoch 154/167 - loss=0.74093413, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50867802, MSE_maskV_-1.0=0.74057084, val_loss=0.840635, val_CC_maskV_-1.0=0.44853812, val_MSE_maskV_-1.0=0.8372888, learning_rate=0.001\n", + "Epoch 167/167 - loss=0.73925376, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51027066, MSE_maskV_-1.0=0.7389226, val_loss=0.84514415, val_CC_maskV_-1.0=0.44578308, val_MSE_maskV_-1.0=0.84225291, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:49:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 44.31s\n", + "\u001b[32m2025-05-30 16:49:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.83732891)\n", + "\u001b[32m2025-05-30 16:49:33\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 902us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:49:34\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.736, R2_maskV_-1.0=0.264, CC_maskV_-1.0=0.515\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 824us/step\n", + "51/51 [==============================] - 0s 778us/step\n", + "84/84 [==============================] - 0s 812us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:49:35\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_uAKCy1HL64U_ErSV16\" (13/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_uAKCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:49:35\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_ACzCy1HL64U_ErSV16\" (14/16)\n", + "\u001b[32m2025-05-30 16:49:35\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_ACzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:49:35\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:49:35\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:49:35\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:49:35\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:49:35\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:49:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:49:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 183 (stopped at 198 epochs).\n", + "\u001b[32m2025-05-30 16:49:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/199 - loss=rnn_1step_loss=1.0052093, rnn_1step_R2_maskV_-1.0=-0.010579668, rnn_1step_CC_maskV_-1.0=0.084246576, rnn_1step_MSE_maskV_-1.0=1.0052094, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.088782, val_rnn_1step_R2_maskV_-1.0=-0.041730806, val_rnn_1step_CC_maskV_-1.0=0.18020928, learning_rate=0.001\n", + "Epoch 21/199 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.64280391, rnn_1step_R2_maskV_-1.0=0.34765035, rnn_1step_CC_maskV_-1.0=0.60211354, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.75630212, val_rnn_1step_R2_maskV_-1.0=0.27636102, val_rnn_1step_CC_maskV_-1.0=0.56182247, learning_rate=0.001\n", + "Epoch 41/199 - loss=rnn_1step_loss=0.47519541, rnn_1step_R2_maskV_-1.0=0.51663333, rnn_1step_CC_maskV_-1.0=0.72604942, rnn_1step_MSE_maskV_-1.0=0.47519538, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.62283885, val_rnn_1step_R2_maskV_-1.0=0.40427262, val_rnn_1step_CC_maskV_-1.0=0.65342224, learning_rate=0.001\n", + "Epoch 61/199 - loss=rnn_1step_loss=0.40452543, rnn_1step_R2_maskV_-1.0=0.58723295, rnn_1step_CC_maskV_-1.0=0.77339172, rnn_1step_MSE_maskV_-1.0=0.40452546, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5592137, val_rnn_1step_R2_maskV_-1.0=0.46125582, val_rnn_1step_CC_maskV_-1.0=0.69635397, learning_rate=0.001\n", + "Epoch 81/199 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.35772061, rnn_1step_R2_maskV_-1.0=0.63494068, rnn_1step_CC_maskV_-1.0=0.80370063, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51256251, val_rnn_1step_R2_maskV_-1.0=0.50613916, val_rnn_1step_CC_maskV_-1.0=0.72530371, learning_rate=0.001\n", + "Epoch 101/199 - loss=rnn_1step_loss=0.33594742, rnn_1step_R2_maskV_-1.0=0.65669173, rnn_1step_CC_maskV_-1.0=0.81678832, rnn_1step_MSE_maskV_-1.0=0.33594745, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47759905, val_rnn_1step_R2_maskV_-1.0=0.54028732, val_rnn_1step_CC_maskV_-1.0=0.74894112, learning_rate=0.001\n", + "Epoch 121/199 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.31529751, rnn_1step_R2_maskV_-1.0=0.67763245, rnn_1step_CC_maskV_-1.0=0.82999647, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45905674, val_rnn_1step_R2_maskV_-1.0=0.55868936, val_rnn_1step_CC_maskV_-1.0=0.76048046, learning_rate=0.001\n", + "Epoch 141/199 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.30686095, rnn_1step_R2_maskV_-1.0=0.68621063, rnn_1step_CC_maskV_-1.0=0.83489448, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44956288, val_rnn_1step_R2_maskV_-1.0=0.56718445, val_rnn_1step_CC_maskV_-1.0=0.76879191, learning_rate=0.001\n", + "Epoch 161/199 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.29280195, rnn_1step_R2_maskV_-1.0=0.70008874, rnn_1step_CC_maskV_-1.0=0.84296411, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45930085, val_rnn_1step_R2_maskV_-1.0=0.55797887, val_rnn_1step_CC_maskV_-1.0=0.76536447, learning_rate=0.001\n", + "Epoch 181/199 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.28512254, rnn_1step_R2_maskV_-1.0=0.70752513, rnn_1step_CC_maskV_-1.0=0.84746403, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44781172, val_rnn_1step_R2_maskV_-1.0=0.56902862, val_rnn_1step_CC_maskV_-1.0=0.77183253, learning_rate=0.001\n", + "Epoch 199/199 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.28238308, rnn_1step_R2_maskV_-1.0=0.71017498, rnn_1step_CC_maskV_-1.0=0.84854978, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42846942, val_rnn_1step_R2_maskV_-1.0=0.58839369, val_rnn_1step_CC_maskV_-1.0=0.77902842, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:49:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 23.38s\n", + "\u001b[32m2025-05-30 16:49:58\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:50:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 140 (stopped at 155 epochs).\n", + "\u001b[32m2025-05-30 16:50:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/156 - loss=rnn_1_1step_loss=1.0049776, rnn_1_1step_R2_maskV_-1.0=-0.010362353, rnn_1_1step_CC_maskV_-1.0=0.13295241, rnn_1_1step_MSE_maskV_-1.0=1.0049775, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.088999, val_rnn_1_1step_R2_maskV_-1.0=-0.041952744, val_rnn_1_1step_CC_maskV_-1.0=0.2252153, learning_rate=0.001\n", + "Epoch 17/156 - loss=rnn_1_1step_loss=0.68186408, rnn_1_1step_R2_maskV_-1.0=0.30855876, rnn_1_1step_CC_maskV_-1.0=0.56845295, rnn_1_1step_MSE_maskV_-1.0=0.68186402, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.78509563, val_rnn_1_1step_R2_maskV_-1.0=0.2465926, val_rnn_1_1step_CC_maskV_-1.0=0.53955656, learning_rate=0.001\n", + "Epoch 33/156 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.51710463, rnn_1_1step_R2_maskV_-1.0=0.47354117, rnn_1_1step_CC_maskV_-1.0=0.69642806, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65336281, val_rnn_1_1step_R2_maskV_-1.0=0.37326682, val_rnn_1_1step_CC_maskV_-1.0=0.63188475, learning_rate=0.001\n", + "Epoch 49/156 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.46289197, rnn_1_1step_R2_maskV_-1.0=0.52755874, rnn_1_1step_CC_maskV_-1.0=0.7342186, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.59675103, val_rnn_1_1step_R2_maskV_-1.0=0.42800879, val_rnn_1_1step_CC_maskV_-1.0=0.67088598, learning_rate=0.001\n", + "Epoch 65/156 - loss=rnn_1_1step_loss=0.42493644, rnn_1_1step_R2_maskV_-1.0=0.56524831, rnn_1_1step_CC_maskV_-1.0=0.75969362, rnn_1_1step_MSE_maskV_-1.0=0.42493647, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.54303747, val_rnn_1_1step_R2_maskV_-1.0=0.47908485, val_rnn_1_1step_CC_maskV_-1.0=0.70570779, learning_rate=0.001\n", + "Epoch 81/156 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.38460073, rnn_1_1step_R2_maskV_-1.0=0.60553944, rnn_1_1step_CC_maskV_-1.0=0.7855643, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48759556, val_rnn_1_1step_R2_maskV_-1.0=0.53177053, val_rnn_1_1step_CC_maskV_-1.0=0.74118125, learning_rate=0.001\n", + "Epoch 97/156 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.36675826, rnn_1_1step_R2_maskV_-1.0=0.62345386, rnn_1_1step_CC_maskV_-1.0=0.79685777, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4836413, val_rnn_1_1step_R2_maskV_-1.0=0.53622001, val_rnn_1_1step_CC_maskV_-1.0=0.7450828, learning_rate=0.001\n", + "Epoch 113/156 - loss=rnn_1_1step_loss=0.34681782, rnn_1_1step_R2_maskV_-1.0=0.64369535, rnn_1_1step_CC_maskV_-1.0=0.80958593, rnn_1_1step_MSE_maskV_-1.0=0.34681779, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46353468, val_rnn_1_1step_R2_maskV_-1.0=0.5557462, val_rnn_1_1step_CC_maskV_-1.0=0.75550508, learning_rate=0.001\n", + "Epoch 129/156 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.33936188, rnn_1_1step_R2_maskV_-1.0=0.65055072, rnn_1_1step_CC_maskV_-1.0=0.81517053, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45308563, val_rnn_1_1step_R2_maskV_-1.0=0.56579018, val_rnn_1_1step_CC_maskV_-1.0=0.76100403, learning_rate=0.001\n", + "Epoch 145/156 - loss=rnn_1_1step_loss=0.31903157, rnn_1_1step_R2_maskV_-1.0=0.67227137, rnn_1_1step_CC_maskV_-1.0=0.82707363, rnn_1_1step_MSE_maskV_-1.0=0.3190316, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.4517298, val_rnn_1_1step_R2_maskV_-1.0=0.5666191, val_rnn_1_1step_CC_maskV_-1.0=0.76269257, learning_rate=0.001\n", + "Epoch 156/156 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31450546, rnn_1_1step_R2_maskV_-1.0=0.67686766, rnn_1_1step_CC_maskV_-1.0=0.82952845, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.44636753, val_rnn_1_1step_R2_maskV_-1.0=0.57196462, val_rnn_1_1step_CC_maskV_-1.0=0.76765859, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:50:17\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 18.89s\n", + "\u001b[32m2025-05-30 16:50:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.42390928)\n", + "\u001b[32m2025-05-30 16:50:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.258, R2_maskV_-1.0=0.742, CC_maskV_-1.0=0.862\n", + "\u001b[32m2025-05-30 16:50:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.397, R2_maskV_-1.0=0.61, CC_maskV_-1.0=0.791\n", + "\u001b[32m2025-05-30 16:50:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:50:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:50:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 123 (stopped at 138 epochs).\n", + "\u001b[32m2025-05-30 16:50:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/139 - loss=1.340286, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.14267993, MSE_maskV_-1.0=1.3402945, val_loss=1.0247725, val_CC_maskV_-1.0=0.23070601, val_MSE_maskV_-1.0=1.0181223, learning_rate=0.001\n", + "Epoch 15/139 - loss=0.70322162, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.54425979, MSE_maskV_-1.0=0.70357305, val_loss=0.77681428, val_CC_maskV_-1.0=0.5003832, val_MSE_maskV_-1.0=0.77346164, learning_rate=0.001\n", + "Epoch 29/139 - loss=0.66492039, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.57804424, MSE_maskV_-1.0=0.66517979, val_loss=0.74347472, val_CC_maskV_-1.0=0.52965933, val_MSE_maskV_-1.0=0.74019706, learning_rate=0.001\n", + "Epoch 43/139 - loss=0.64819205, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59130162, MSE_maskV_-1.0=0.64752179, val_loss=0.73235679, val_CC_maskV_-1.0=0.54007041, val_MSE_maskV_-1.0=0.72920895, learning_rate=0.001\n", + "Epoch 57/139 - loss=0.63903874, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.59988117, MSE_maskV_-1.0=0.63867408, val_loss=0.7185263, val_CC_maskV_-1.0=0.54954606, val_MSE_maskV_-1.0=0.71582144, learning_rate=0.001\n", + "Epoch 71/139 - loss=0.63259739, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60527229, MSE_maskV_-1.0=0.63243246, val_loss=0.71356755, val_CC_maskV_-1.0=0.55436701, val_MSE_maskV_-1.0=0.7107116, learning_rate=0.001\n", + "Epoch 85/139 - loss=0.62857765, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6083343, MSE_maskV_-1.0=0.62871736, val_loss=0.71073002, val_CC_maskV_-1.0=0.55671889, val_MSE_maskV_-1.0=0.70814806, learning_rate=0.001\n", + "Epoch 99/139 - loss=0.62434191, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61225623, MSE_maskV_-1.0=0.62423337, val_loss=0.71166605, val_CC_maskV_-1.0=0.55669892, val_MSE_maskV_-1.0=0.70873886, learning_rate=0.001\n", + "Epoch 113/139 - loss=0.6216532, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61459881, MSE_maskV_-1.0=0.62180972, val_loss=0.70704228, val_CC_maskV_-1.0=0.56137025, val_MSE_maskV_-1.0=0.70417905, learning_rate=0.001\n", + "Epoch 127/139 - loss=0.61835098, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61648333, MSE_maskV_-1.0=0.61827123, val_loss=0.70770669, val_CC_maskV_-1.0=0.56088698, val_MSE_maskV_-1.0=0.7048921, learning_rate=0.001\n", + "Epoch 139/139 - loss=0.61676264, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61847782, MSE_maskV_-1.0=0.6169188, val_loss=0.70638269, val_CC_maskV_-1.0=0.56234115, val_MSE_maskV_-1.0=0.70344126, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:50:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 37.31s\n", + "\u001b[32m2025-05-30 16:50:56\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:51:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 177 (stopped at 192 epochs).\n", + "\u001b[32m2025-05-30 16:51:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/193 - loss=1.5217346, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.1042598, MSE_maskV_-1.0=1.5214922, val_loss=1.077698, val_CC_maskV_-1.0=0.16598251, val_MSE_maskV_-1.0=1.0723538, learning_rate=0.001\n", + "Epoch 21/193 - loss=0.6839726, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.56135112, MSE_maskV_-1.0=0.68389559, val_loss=0.7589224, val_CC_maskV_-1.0=0.5166074, val_MSE_maskV_-1.0=0.7566244, learning_rate=0.001\n", + "Epoch 41/193 - loss=0.65178436, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.58901733, MSE_maskV_-1.0=0.65166521, val_loss=0.73661989, val_CC_maskV_-1.0=0.53672725, val_MSE_maskV_-1.0=0.73419887, learning_rate=0.001\n", + "Epoch 61/193 - loss=0.63801086, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60050207, MSE_maskV_-1.0=0.63798976, val_loss=0.72358471, val_CC_maskV_-1.0=0.54571569, val_MSE_maskV_-1.0=0.72139734, learning_rate=0.001\n", + "Epoch 81/193 - loss=0.62918633, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.60731, MSE_maskV_-1.0=0.62916321, val_loss=0.71316552, val_CC_maskV_-1.0=0.5540486, val_MSE_maskV_-1.0=0.71094728, learning_rate=0.001\n", + "Epoch 101/193 - loss=0.62429738, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61177182, MSE_maskV_-1.0=0.62448508, val_loss=0.70843101, val_CC_maskV_-1.0=0.55821782, val_MSE_maskV_-1.0=0.70601851, learning_rate=0.001\n", + "Epoch 121/193 - loss=0.61903465, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61665052, MSE_maskV_-1.0=0.61943138, val_loss=0.7056585, val_CC_maskV_-1.0=0.56063563, val_MSE_maskV_-1.0=0.70348769, learning_rate=0.001\n", + "Epoch 141/193 - loss=0.61522239, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.61976451, MSE_maskV_-1.0=0.61536139, val_loss=0.7047435, val_CC_maskV_-1.0=0.56236702, val_MSE_maskV_-1.0=0.70232099, learning_rate=0.001\n", + "Epoch 161/193 - loss=0.61260009, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62164283, MSE_maskV_-1.0=0.61276364, val_loss=0.70425713, val_CC_maskV_-1.0=0.56190234, val_MSE_maskV_-1.0=0.70205486, learning_rate=0.001\n", + "Epoch 181/193 - loss=0.60937488, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.6242559, MSE_maskV_-1.0=0.60909235, val_loss=0.70442045, val_CC_maskV_-1.0=0.56358927, val_MSE_maskV_-1.0=0.70191973, learning_rate=0.001\n", + "Epoch 193/193 - loss=0.60825068, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.62454581, MSE_maskV_-1.0=0.60788077, val_loss=0.70336151, val_CC_maskV_-1.0=0.56596869, val_MSE_maskV_-1.0=0.70055896, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:51:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 50.95s\n", + "\u001b[32m2025-05-30 16:51:47\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.69760966)\n", + "\u001b[32m2025-05-30 16:51:47\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 824us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:51:48\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.604, R2_maskV_-1.0=0.396, CC_maskV_-1.0=0.63\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 838us/step\n", + "51/51 [==============================] - 0s 888us/step\n", + "84/84 [==============================] - 0s 770us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:51:48\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_ACzCy1HL64U_ErSV16\" (14/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_ACzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:51:48\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_KCzCy1HL64U_ErSV16\" (15/16)\n", + "\u001b[32m2025-05-30 16:51:48\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_KCzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:51:48\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:51:48\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:51:49\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:51:49\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:51:49\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:51:49\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:52:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 197 (stopped at 212 epochs).\n", + "\u001b[32m2025-05-30 16:52:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/213 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0058731, rnn_1step_R2_maskV_-1.0=-0.011306755, rnn_1step_CC_maskV_-1.0=0.042628899, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0911084, val_rnn_1step_R2_maskV_-1.0=-0.043971986, val_rnn_1step_CC_maskV_-1.0=0.13288915, learning_rate=0.001\n", + "Epoch 23/213 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.59140259, rnn_1step_R2_maskV_-1.0=0.40027517, rnn_1step_CC_maskV_-1.0=0.64322406, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.72193462, val_rnn_1step_R2_maskV_-1.0=0.3034105, val_rnn_1step_CC_maskV_-1.0=0.58726454, learning_rate=0.001\n", + "Epoch 45/213 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.42401612, rnn_1step_R2_maskV_-1.0=0.56872475, rnn_1step_CC_maskV_-1.0=0.76095122, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.5429737, val_rnn_1step_R2_maskV_-1.0=0.48110765, val_rnn_1step_CC_maskV_-1.0=0.70357436, learning_rate=0.001\n", + "Epoch 67/213 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.33195165, rnn_1step_R2_maskV_-1.0=0.66072619, rnn_1step_CC_maskV_-1.0=0.81912839, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47730592, val_rnn_1step_R2_maskV_-1.0=0.54316378, val_rnn_1step_CC_maskV_-1.0=0.7457428, learning_rate=0.001\n", + "Epoch 89/213 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.28302589, rnn_1step_R2_maskV_-1.0=0.71064895, rnn_1step_CC_maskV_-1.0=0.84847778, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.46978286, val_rnn_1step_R2_maskV_-1.0=0.55149996, val_rnn_1step_CC_maskV_-1.0=0.75268018, learning_rate=0.001\n", + "Epoch 111/213 - loss=rnn_1step_loss=0.24955843, rnn_1step_R2_maskV_-1.0=0.74518341, rnn_1step_CC_maskV_-1.0=0.86794376, rnn_1step_MSE_maskV_-1.0=0.24955842, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45802709, val_rnn_1step_R2_maskV_-1.0=0.56348968, val_rnn_1step_CC_maskV_-1.0=0.76121545, learning_rate=0.001\n", + "Epoch 133/213 - loss=rnn_1step_loss=0.22426255, rnn_1step_R2_maskV_-1.0=0.77068424, rnn_1step_CC_maskV_-1.0=0.88164604, rnn_1step_MSE_maskV_-1.0=0.22426258, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45834658, val_rnn_1step_R2_maskV_-1.0=0.5634917, val_rnn_1step_CC_maskV_-1.0=0.76336199, learning_rate=0.001\n", + "Epoch 155/213 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.19205765, rnn_1step_R2_maskV_-1.0=0.80394286, rnn_1step_CC_maskV_-1.0=0.89987391, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.43021858, val_rnn_1step_R2_maskV_-1.0=0.58910757, val_rnn_1step_CC_maskV_-1.0=0.77695864, learning_rate=0.001\n", + "Epoch 177/213 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.17659146, rnn_1step_R2_maskV_-1.0=0.81945455, rnn_1step_CC_maskV_-1.0=0.90813422, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.41882953, val_rnn_1step_R2_maskV_-1.0=0.59970778, val_rnn_1step_CC_maskV_-1.0=0.78397483, learning_rate=0.001\n", + "Epoch 199/213 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.16834338, rnn_1step_R2_maskV_-1.0=0.82735795, rnn_1step_CC_maskV_-1.0=0.91249323, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.42280102, val_rnn_1step_R2_maskV_-1.0=0.59576023, val_rnn_1step_CC_maskV_-1.0=0.78197247, learning_rate=0.001\n", + "Epoch 213/213 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.15992832, rnn_1step_R2_maskV_-1.0=0.83601093, rnn_1step_CC_maskV_-1.0=0.91701734, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.41893557, val_rnn_1step_R2_maskV_-1.0=0.59909838, val_rnn_1step_CC_maskV_-1.0=0.78415775, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:52:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 23.25s\n", + "\u001b[32m2025-05-30 16:52:12\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:52:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 171 (stopped at 186 epochs).\n", + "\u001b[32m2025-05-30 16:52:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/187 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0059272, rnn_1_1step_R2_maskV_-1.0=-0.011360589, rnn_1_1step_CC_maskV_-1.0=0.0071046408, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0909551, val_rnn_1_1step_R2_maskV_-1.0=-0.043800712, val_rnn_1_1step_CC_maskV_-1.0=0.11954062, learning_rate=0.001\n", + "Epoch 20/187 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.67485708, rnn_1_1step_R2_maskV_-1.0=0.31550014, rnn_1_1step_CC_maskV_-1.0=0.57403731, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.78498334, val_rnn_1_1step_R2_maskV_-1.0=0.2474495, val_rnn_1_1step_CC_maskV_-1.0=0.53242391, learning_rate=0.001\n", + "Epoch 39/187 - loss=rnn_1_1step_loss=0.47654161, rnn_1_1step_R2_maskV_-1.0=0.51549524, rnn_1_1step_CC_maskV_-1.0=0.72550261, rnn_1_1step_MSE_maskV_-1.0=0.47654158, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.60715169, val_rnn_1_1step_R2_maskV_-1.0=0.41535777, val_rnn_1_1step_CC_maskV_-1.0=0.66113657, learning_rate=0.001\n", + "Epoch 58/187 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.35758188, rnn_1_1step_R2_maskV_-1.0=0.63464159, rnn_1_1step_CC_maskV_-1.0=0.80382907, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.494818, val_rnn_1_1step_R2_maskV_-1.0=0.52590692, val_rnn_1_1step_CC_maskV_-1.0=0.73499423, learning_rate=0.001\n", + "Epoch 77/187 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.30110753, rnn_1_1step_R2_maskV_-1.0=0.69164801, rnn_1_1step_CC_maskV_-1.0=0.83775407, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47098002, val_rnn_1_1step_R2_maskV_-1.0=0.54864204, val_rnn_1_1step_CC_maskV_-1.0=0.75049239, learning_rate=0.001\n", + "Epoch 96/187 - loss=rnn_1_1step_loss=0.26363227, rnn_1_1step_R2_maskV_-1.0=0.72977895, rnn_1_1step_CC_maskV_-1.0=0.85952932, rnn_1_1step_MSE_maskV_-1.0=0.26363224, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.46681654, val_rnn_1_1step_R2_maskV_-1.0=0.55244762, val_rnn_1_1step_CC_maskV_-1.0=0.75411433, learning_rate=0.001\n", + "Epoch 115/187 - loss=rnn_1_1step_loss=0.23697858, rnn_1_1step_R2_maskV_-1.0=0.75772178, rnn_1_1step_CC_maskV_-1.0=0.87517893, rnn_1_1step_MSE_maskV_-1.0=0.23697856, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.45124006, val_rnn_1_1step_R2_maskV_-1.0=0.56733924, val_rnn_1_1step_CC_maskV_-1.0=0.76460785, learning_rate=0.001\n", + "Epoch 134/187 - loss=rnn_1_1step_loss=0.21317828, rnn_1_1step_R2_maskV_-1.0=0.78154051, rnn_1_1step_CC_maskV_-1.0=0.88808352, rnn_1_1step_MSE_maskV_-1.0=0.21317829, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.44633165, val_rnn_1_1step_R2_maskV_-1.0=0.5724107, val_rnn_1_1step_CC_maskV_-1.0=0.77055216, learning_rate=0.001\n", + "Epoch 153/187 - loss=rnn_1_1step_loss=0.19443738, rnn_1_1step_R2_maskV_-1.0=0.80077672, rnn_1_1step_CC_maskV_-1.0=0.89820588, rnn_1_1step_MSE_maskV_-1.0=0.19443737, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.44433054, val_rnn_1_1step_R2_maskV_-1.0=0.57446384, val_rnn_1_1step_CC_maskV_-1.0=0.77229518, learning_rate=0.001\n", + "Epoch 172/187 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.18161072, rnn_1_1step_R2_maskV_-1.0=0.81370413, rnn_1_1step_CC_maskV_-1.0=0.90578341, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.44881475, val_rnn_1_1step_R2_maskV_-1.0=0.56860346, val_rnn_1_1step_CC_maskV_-1.0=0.77017105, learning_rate=0.001\n", + "Epoch 187/187 - loss=rnn_1_1step_loss=0.1804067, rnn_1_1step_R2_maskV_-1.0=0.81516612, rnn_1_1step_CC_maskV_-1.0=0.90590143, rnn_1_1step_MSE_maskV_-1.0=0.18040672, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.44785598, val_rnn_1_1step_R2_maskV_-1.0=0.57038879, val_rnn_1_1step_CC_maskV_-1.0=0.76901966, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:52:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 20.73s\n", + "\u001b[32m2025-05-30 16:52:33\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.41001847)\n", + "\u001b[32m2025-05-30 16:52:34\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.153, R2_maskV_-1.0=0.847, CC_maskV_-1.0=0.921\n", + "\u001b[32m2025-05-30 16:52:34\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.365, R2_maskV_-1.0=0.642, CC_maskV_-1.0=0.81\n", + "\u001b[32m2025-05-30 16:52:34\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:52:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:53:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 103 (stopped at 118 epochs).\n", + "\u001b[32m2025-05-30 16:53:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/119 - loss=1.4961373, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.075761355, MSE_maskV_-1.0=1.4958256, val_loss=1.0698477, val_CC_maskV_-1.0=0.14112481, val_MSE_maskV_-1.0=1.0645134, learning_rate=0.001\n", + "Epoch 13/119 - loss=0.83146924, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.41054526, MSE_maskV_-1.0=0.83071893, val_loss=0.91123652, val_CC_maskV_-1.0=0.37066343, val_MSE_maskV_-1.0=0.9075917, learning_rate=0.001\n", + "Epoch 25/119 - loss=0.79325813, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45535162, MSE_maskV_-1.0=0.7928409, val_loss=0.87946486, val_CC_maskV_-1.0=0.40879026, val_MSE_maskV_-1.0=0.87594455, learning_rate=0.001\n", + "Epoch 37/119 - loss=0.77052265, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.47984365, MSE_maskV_-1.0=0.77051055, val_loss=0.85842705, val_CC_maskV_-1.0=0.42884412, val_MSE_maskV_-1.0=0.85540056, learning_rate=0.001\n", + "Epoch 49/119 - loss=0.75356352, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49714816, MSE_maskV_-1.0=0.75324565, val_loss=0.83635008, val_CC_maskV_-1.0=0.45017275, val_MSE_maskV_-1.0=0.83362168, learning_rate=0.001\n", + "Epoch 61/119 - loss=0.74290073, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50707507, MSE_maskV_-1.0=0.74313748, val_loss=0.82661623, val_CC_maskV_-1.0=0.45921761, val_MSE_maskV_-1.0=0.82408291, learning_rate=0.001\n", + "Epoch 73/119 - loss=0.73391664, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51582217, MSE_maskV_-1.0=0.73358053, val_loss=0.82521355, val_CC_maskV_-1.0=0.45887142, val_MSE_maskV_-1.0=0.82266665, learning_rate=0.001\n", + "Epoch 85/119 - loss=0.72817218, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52096879, MSE_maskV_-1.0=0.7286433, val_loss=0.81544709, val_CC_maskV_-1.0=0.46669534, val_MSE_maskV_-1.0=0.81297666, learning_rate=0.001\n", + "Epoch 97/119 - loss=0.72228503, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52720451, MSE_maskV_-1.0=0.72224391, val_loss=0.80821383, val_CC_maskV_-1.0=0.47227556, val_MSE_maskV_-1.0=0.80578607, learning_rate=0.001\n", + "Epoch 109/119 - loss=0.71900189, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52948809, MSE_maskV_-1.0=0.71892738, val_loss=0.80474222, val_CC_maskV_-1.0=0.47484946, val_MSE_maskV_-1.0=0.80250597, learning_rate=0.001\n", + "Epoch 119/119 - loss=0.71751904, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53110033, MSE_maskV_-1.0=0.7167725, val_loss=0.79995334, val_CC_maskV_-1.0=0.4781993, val_MSE_maskV_-1.0=0.79779899, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:53:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 32.16s\n", + "\u001b[32m2025-05-30 16:53:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:53:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 80 (stopped at 95 epochs).\n", + "\u001b[32m2025-05-30 16:53:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/96 - loss=1.5093061, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.078634582, MSE_maskV_-1.0=1.5088341, val_loss=1.0780922, val_CC_maskV_-1.0=0.12757309, val_MSE_maskV_-1.0=1.0704502, learning_rate=0.001\n", + "Epoch 11/96 - loss=0.84224647, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.39741766, MSE_maskV_-1.0=0.84227264, val_loss=0.9152962, val_CC_maskV_-1.0=0.36890972, val_MSE_maskV_-1.0=0.9106499, learning_rate=0.001\n", + "Epoch 21/96 - loss=0.80553222, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.4411495, MSE_maskV_-1.0=0.80545425, val_loss=0.88600284, val_CC_maskV_-1.0=0.40088227, val_MSE_maskV_-1.0=0.88202751, learning_rate=0.001\n", + "Epoch 31/96 - loss=0.78303385, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.46714646, MSE_maskV_-1.0=0.78257614, val_loss=0.86200029, val_CC_maskV_-1.0=0.42792755, val_MSE_maskV_-1.0=0.85838836, learning_rate=0.001\n", + "Epoch 41/96 - loss=0.76580697, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48411143, MSE_maskV_-1.0=0.76551491, val_loss=0.84673721, val_CC_maskV_-1.0=0.4410302, val_MSE_maskV_-1.0=0.84323907, learning_rate=0.001\n", + "Epoch 51/96 - loss=0.75364012, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.49684477, MSE_maskV_-1.0=0.75414115, val_loss=0.84386295, val_CC_maskV_-1.0=0.44506723, val_MSE_maskV_-1.0=0.84037554, learning_rate=0.001\n", + "Epoch 61/96 - loss=0.74433988, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50544453, MSE_maskV_-1.0=0.74450624, val_loss=0.82554013, val_CC_maskV_-1.0=0.45957741, val_MSE_maskV_-1.0=0.82221669, learning_rate=0.001\n", + "Epoch 71/96 - loss=0.73631239, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51368856, MSE_maskV_-1.0=0.73602927, val_loss=0.82068944, val_CC_maskV_-1.0=0.46377113, val_MSE_maskV_-1.0=0.81737691, learning_rate=0.001\n", + "Epoch 81/96 - loss=0.73123592, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5176959, MSE_maskV_-1.0=0.73130661, val_loss=0.80879921, val_CC_maskV_-1.0=0.47235653, val_MSE_maskV_-1.0=0.80577505, learning_rate=0.001\n", + "Epoch 91/96 - loss=0.72732425, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5213902, MSE_maskV_-1.0=0.7276336, val_loss=0.81485176, val_CC_maskV_-1.0=0.4676891, val_MSE_maskV_-1.0=0.81152707, learning_rate=0.001\n", + "Epoch 96/96 - loss=0.72466445, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52440041, MSE_maskV_-1.0=0.72455519, val_loss=0.81142038, val_CC_maskV_-1.0=0.46929434, val_MSE_maskV_-1.0=0.80835891, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:53:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 25.93s\n", + "\u001b[32m2025-05-30 16:53:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.79775733)\n", + "\u001b[32m2025-05-30 16:53:32\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 908us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:53:33\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.717, R2_maskV_-1.0=0.283, CC_maskV_-1.0=0.533\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 797us/step\n", + "51/51 [==============================] - 0s 937us/step\n", + "84/84 [==============================] - 0s 746us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:53:34\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_KCzCy1HL64U_ErSV16\" (15/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_KCzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:53:34\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2166] \u001b[1;30mINFO\u001b[0m Working on fold 4/4 method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16\" (16/16)\n", + "\u001b[32m2025-05-30 16:53:34\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2892] \u001b[1;30mINFO\u001b[0m Working on method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16 nx=16\"\n", + "\u001b[32m2025-05-30 16:53:34\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2933] \u001b[1;30mINFO\u001b[0m DPAD.fit args: {'init_method': None, 'init_attempts': 2, 'batch_size': None, 'early_stopping_patience': 16, 'early_stopping_measure': 'val_loss', 'start_from_epoch_rnn': 0, 'model1_Cy_Full': False, 'model2_Cz_Full': False, 'linear_cell': False, 'LSTM_cell': False, 'bidirectional': False, 'allow_nonzero_Cz2': True, 'has_Dyz': False, 'skip_Cy': False, 'steps_ahead': None, 'steps_ahead_loss_weights': None, 'zscore_inputs': True, 'optimizer_name': 'Adam', 'optimizer_args': None, 'lr_scheduler_name': None, 'lr_scheduler_args': None, 'A_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'K_args': {'use_bias': True, 'units': [64], 'activation': 'relu', 'unifiedAK': True}, 'Cy_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'Cz_args': {'use_bias': True, 'units': [64], 'activation': 'relu'}, 'epochs': 2500}\n", + "\u001b[32m2025-05-30 16:53:34\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-30 16:53:34\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-30 16:53:34\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-30 16:53:34\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 12 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-30 16:53:34\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:54:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 239 (stopped at 254 epochs).\n", + "\u001b[32m2025-05-30 16:54:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/255 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=1.0058562, rnn_1step_R2_maskV_-1.0=-0.011277087, rnn_1step_CC_maskV_-1.0=0.047842942, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=1.0907668, val_rnn_1step_R2_maskV_-1.0=-0.043626517, val_rnn_1step_CC_maskV_-1.0=0.18017358, learning_rate=0.001\n", + "Epoch 27/255 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.59599423, rnn_1step_R2_maskV_-1.0=0.39405227, rnn_1step_CC_maskV_-1.0=0.63775969, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.73074198, val_rnn_1step_R2_maskV_-1.0=0.29487896, val_rnn_1step_CC_maskV_-1.0=0.57285076, learning_rate=0.001\n", + "Epoch 53/255 - loss=rnn_1step_loss=0.41345343, rnn_1step_R2_maskV_-1.0=0.57760346, rnn_1step_CC_maskV_-1.0=0.76874089, rnn_1step_MSE_maskV_-1.0=0.4134534, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.57104868, val_rnn_1step_R2_maskV_-1.0=0.45258471, val_rnn_1step_CC_maskV_-1.0=0.68884969, learning_rate=0.001\n", + "Epoch 79/255 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.32402113, rnn_1step_R2_maskV_-1.0=0.66697943, rnn_1step_CC_maskV_-1.0=0.82294077, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.51444286, val_rnn_1step_R2_maskV_-1.0=0.50777292, val_rnn_1step_CC_maskV_-1.0=0.72582299, learning_rate=0.001\n", + "Epoch 105/255 - loss=rnn_1step_loss=0.28024721, rnn_1step_R2_maskV_-1.0=0.71148074, rnn_1step_CC_maskV_-1.0=0.84962237, rnn_1step_MSE_maskV_-1.0=0.28024724, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.50178725, val_rnn_1step_R2_maskV_-1.0=0.51956648, val_rnn_1step_CC_maskV_-1.0=0.73295492, learning_rate=0.001\n", + "Epoch 131/255 - loss=rnn_1step_loss=0.25032339, rnn_1step_R2_maskV_-1.0=0.74244928, rnn_1step_CC_maskV_-1.0=0.86660856, rnn_1step_MSE_maskV_-1.0=0.25032336, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47897145, val_rnn_1step_R2_maskV_-1.0=0.5405938, val_rnn_1step_CC_maskV_-1.0=0.74901342, learning_rate=0.001\n", + "Epoch 157/255 - loss=rnn_1step_loss=0.22846745, rnn_1step_R2_maskV_-1.0=0.76465213, rnn_1step_CC_maskV_-1.0=0.87919402, rnn_1step_MSE_maskV_-1.0=0.22846743, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.47371888, val_rnn_1step_R2_maskV_-1.0=0.54523492, val_rnn_1step_CC_maskV_-1.0=0.75148529, learning_rate=0.001\n", + "Epoch 183/255 - loss=rnn_1step_loss=0.210155, rnn_1step_R2_maskV_-1.0=0.78401321, rnn_1step_CC_maskV_-1.0=0.88927203, rnn_1step_MSE_maskV_-1.0=0.21015498, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45230541, val_rnn_1step_R2_maskV_-1.0=0.56582427, val_rnn_1step_CC_maskV_-1.0=0.76530111, learning_rate=0.001\n", + "Epoch 209/255 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.198615, rnn_1step_R2_maskV_-1.0=0.79602271, rnn_1step_CC_maskV_-1.0=0.89599639, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.44800282, val_rnn_1step_R2_maskV_-1.0=0.568452, val_rnn_1step_CC_maskV_-1.0=0.76582062, learning_rate=0.001\n", + "Epoch 235/255 - loss=rnn_1step_loss=rnn_1step_MSE_maskV_-1.0=0.18874626, rnn_1step_R2_maskV_-1.0=0.80658358, rnn_1step_CC_maskV_-1.0=0.90151083, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.48415986, val_rnn_1step_R2_maskV_-1.0=0.53268528, val_rnn_1step_CC_maskV_-1.0=0.74691278, learning_rate=0.001\n", + "Epoch 255/255 - loss=rnn_1step_loss=0.17632473, rnn_1step_R2_maskV_-1.0=0.81936347, rnn_1step_CC_maskV_-1.0=0.90817952, rnn_1step_MSE_maskV_-1.0=0.17632471, val_loss=val_rnn_1step_loss=val_rnn_1step_MSE_maskV_-1.0=0.45880595, val_rnn_1step_R2_maskV_-1.0=0.55779552, val_rnn_1step_CC_maskV_-1.0=0.76191092, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:54:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 28.96s\n", + "\u001b[32m2025-05-30 16:54:03\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:54:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 134 (stopped at 149 epochs).\n", + "\u001b[32m2025-05-30 16:54:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/150 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=1.0059129, rnn_1_1step_R2_maskV_-1.0=-0.011335943, rnn_1_1step_CC_maskV_-1.0=0.028055344, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=1.0907248, val_rnn_1_1step_R2_maskV_-1.0=-0.04357639, val_rnn_1_1step_CC_maskV_-1.0=0.18250741, learning_rate=0.001\n", + "Epoch 16/150 - loss=rnn_1_1step_loss=0.66291624, rnn_1_1step_R2_maskV_-1.0=0.32950157, rnn_1_1step_CC_maskV_-1.0=0.58337498, rnn_1_1step_MSE_maskV_-1.0=0.6629163, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.75208449, val_rnn_1_1step_R2_maskV_-1.0=0.27170476, val_rnn_1_1step_CC_maskV_-1.0=0.5531159, learning_rate=0.001\n", + "Epoch 31/150 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.51962787, rnn_1_1step_R2_maskV_-1.0=0.47022933, rnn_1_1step_CC_maskV_-1.0=0.69502383, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.65742046, val_rnn_1_1step_R2_maskV_-1.0=0.36416784, val_rnn_1_1step_CC_maskV_-1.0=0.63145441, learning_rate=0.001\n", + "Epoch 46/150 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.44123581, rnn_1_1step_R2_maskV_-1.0=0.54965323, rnn_1_1step_CC_maskV_-1.0=0.74904615, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.57988936, val_rnn_1_1step_R2_maskV_-1.0=0.44282624, val_rnn_1_1step_CC_maskV_-1.0=0.68115211, learning_rate=0.001\n", + "Epoch 61/150 - loss=rnn_1_1step_loss=0.39996496, rnn_1_1step_R2_maskV_-1.0=0.59126723, rnn_1_1step_CC_maskV_-1.0=0.77600437, rnn_1_1step_MSE_maskV_-1.0=0.39996499, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.56052303, val_rnn_1_1step_R2_maskV_-1.0=0.46201271, val_rnn_1_1step_CC_maskV_-1.0=0.69497353, learning_rate=0.001\n", + "Epoch 76/150 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.35621801, rnn_1_1step_R2_maskV_-1.0=0.63601041, rnn_1_1step_CC_maskV_-1.0=0.80429721, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.53645533, val_rnn_1_1step_R2_maskV_-1.0=0.48398453, val_rnn_1_1step_CC_maskV_-1.0=0.71734399, learning_rate=0.001\n", + "Epoch 91/150 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.31531873, rnn_1_1step_R2_maskV_-1.0=0.67781276, rnn_1_1step_CC_maskV_-1.0=0.82889295, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.49823359, val_rnn_1_1step_R2_maskV_-1.0=0.52117717, val_rnn_1_1step_CC_maskV_-1.0=0.73909861, learning_rate=0.001\n", + "Epoch 106/150 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.28061295, rnn_1_1step_R2_maskV_-1.0=0.71297741, rnn_1_1step_CC_maskV_-1.0=0.84902877, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48606142, val_rnn_1_1step_R2_maskV_-1.0=0.53198522, val_rnn_1_1step_CC_maskV_-1.0=0.74544179, learning_rate=0.001\n", + "Epoch 121/150 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.26213193, rnn_1_1step_R2_maskV_-1.0=0.73192155, rnn_1_1step_CC_maskV_-1.0=0.8602922, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48656043, val_rnn_1_1step_R2_maskV_-1.0=0.53116071, val_rnn_1_1step_CC_maskV_-1.0=0.74557817, learning_rate=0.001\n", + "Epoch 136/150 - loss=rnn_1_1step_loss=rnn_1_1step_MSE_maskV_-1.0=0.2520465, rnn_1_1step_R2_maskV_-1.0=0.74172294, rnn_1_1step_CC_maskV_-1.0=0.86574137, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.47651672, val_rnn_1_1step_R2_maskV_-1.0=0.54093564, val_rnn_1_1step_CC_maskV_-1.0=0.74843621, learning_rate=0.001\n", + "Epoch 150/150 - loss=rnn_1_1step_loss=0.23846893, rnn_1_1step_R2_maskV_-1.0=0.75575006, rnn_1_1step_CC_maskV_-1.0=0.87388313, rnn_1_1step_MSE_maskV_-1.0=0.23846895, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_MSE_maskV_-1.0=0.48417738, val_rnn_1_1step_R2_maskV_-1.0=0.53320408, val_rnn_1_1step_CC_maskV_-1.0=0.74756634, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:54:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 18.12s\n", + "\u001b[32m2025-05-30 16:54:21\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.43335602)\n", + "\u001b[32m2025-05-30 16:54:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.179, R2_maskV_-1.0=0.821, CC_maskV_-1.0=0.906\n", + "\u001b[32m2025-05-30 16:54:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_-1.0=0.429, R2_maskV_-1.0=0.58, CC_maskV_-1.0=0.776\n", + "\u001b[32m2025-05-30 16:54:23\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-30 16:54:23\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-30 16:55:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 147 (stopped at 162 epochs).\n", + "\u001b[32m2025-05-30 16:55:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/163 - loss=1.082804, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.14502844, MSE_maskV_-1.0=1.0838039, val_loss=1.0121924, val_CC_maskV_-1.0=0.22766519, val_MSE_maskV_-1.0=1.0063199, learning_rate=0.001\n", + "Epoch 18/163 - loss=0.79334378, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45607936, MSE_maskV_-1.0=0.79335022, val_loss=0.88690788, val_CC_maskV_-1.0=0.40713543, val_MSE_maskV_-1.0=0.88265759, learning_rate=0.001\n", + "Epoch 35/163 - loss=0.76245135, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48923224, MSE_maskV_-1.0=0.76210123, val_loss=0.85978818, val_CC_maskV_-1.0=0.4355835, val_MSE_maskV_-1.0=0.85573637, learning_rate=0.001\n", + "Epoch 52/163 - loss=0.7469489, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50340152, MSE_maskV_-1.0=0.74691385, val_loss=0.84713417, val_CC_maskV_-1.0=0.44956958, val_MSE_maskV_-1.0=0.84337354, learning_rate=0.001\n", + "Epoch 69/163 - loss=0.73686147, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51390451, MSE_maskV_-1.0=0.7368322, val_loss=0.83872867, val_CC_maskV_-1.0=0.45710889, val_MSE_maskV_-1.0=0.83462346, learning_rate=0.001\n", + "Epoch 86/163 - loss=0.72934049, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52065474, MSE_maskV_-1.0=0.72969061, val_loss=0.82952571, val_CC_maskV_-1.0=0.46503639, val_MSE_maskV_-1.0=0.82575452, learning_rate=0.001\n", + "Epoch 103/163 - loss=0.72482806, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52530664, MSE_maskV_-1.0=0.72466713, val_loss=0.82967085, val_CC_maskV_-1.0=0.46650225, val_MSE_maskV_-1.0=0.82588422, learning_rate=0.001\n", + "Epoch 120/163 - loss=0.71901894, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52990389, MSE_maskV_-1.0=0.7188285, val_loss=0.82428062, val_CC_maskV_-1.0=0.47216016, val_MSE_maskV_-1.0=0.819978, learning_rate=0.001\n", + "Epoch 137/163 - loss=0.71527117, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.5333662, MSE_maskV_-1.0=0.7144475, val_loss=0.81924403, val_CC_maskV_-1.0=0.47499579, val_MSE_maskV_-1.0=0.81528354, learning_rate=0.001\n", + "Epoch 154/163 - loss=0.71185046, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53616816, MSE_maskV_-1.0=0.71145576, val_loss=0.81991309, val_CC_maskV_-1.0=0.47458693, val_MSE_maskV_-1.0=0.81595522, learning_rate=0.001\n", + "Epoch 163/163 - loss=0.71056688, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53864628, MSE_maskV_-1.0=0.71009988, val_loss=0.81820178, val_CC_maskV_-1.0=0.47613469, val_MSE_maskV_-1.0=0.81436431, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:55:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 43.18s\n", + "\u001b[32m2025-05-30 16:55:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-30 16:55:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 145 (stopped at 160 epochs).\n", + "\u001b[32m2025-05-30 16:55:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/161 - loss=1.1111338, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.13267721, MSE_maskV_-1.0=1.1120132, val_loss=1.0175108, val_CC_maskV_-1.0=0.2103003, val_MSE_maskV_-1.0=1.0124627, learning_rate=0.001\n", + "Epoch 18/161 - loss=0.79278338, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.45689228, MSE_maskV_-1.0=0.79274392, val_loss=0.88605386, val_CC_maskV_-1.0=0.4083842, val_MSE_maskV_-1.0=0.88175327, learning_rate=0.001\n", + "Epoch 35/161 - loss=0.76226354, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.48919162, MSE_maskV_-1.0=0.76190853, val_loss=0.86176723, val_CC_maskV_-1.0=0.43253723, val_MSE_maskV_-1.0=0.85780978, learning_rate=0.001\n", + "Epoch 52/161 - loss=0.74566907, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.50471991, MSE_maskV_-1.0=0.74560881, val_loss=0.85142732, val_CC_maskV_-1.0=0.44390491, val_MSE_maskV_-1.0=0.8476283, learning_rate=0.001\n", + "Epoch 69/161 - loss=0.73563242, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.51525569, MSE_maskV_-1.0=0.7356301, val_loss=0.84664166, val_CC_maskV_-1.0=0.44862747, val_MSE_maskV_-1.0=0.84243971, learning_rate=0.001\n", + "Epoch 86/161 - loss=0.72813469, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52187163, MSE_maskV_-1.0=0.72851706, val_loss=0.83475095, val_CC_maskV_-1.0=0.45854735, val_MSE_maskV_-1.0=0.83080965, learning_rate=0.001\n", + "Epoch 103/161 - loss=0.72281843, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.52734882, MSE_maskV_-1.0=0.72257435, val_loss=0.83362585, val_CC_maskV_-1.0=0.46203363, val_MSE_maskV_-1.0=0.82939702, learning_rate=0.001\n", + "Epoch 120/161 - loss=0.71756369, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53135997, MSE_maskV_-1.0=0.71742886, val_loss=0.83037716, val_CC_maskV_-1.0=0.46492961, val_MSE_maskV_-1.0=0.82626486, learning_rate=0.001\n", + "Epoch 137/161 - loss=0.71331191, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53532022, MSE_maskV_-1.0=0.71249467, val_loss=0.82480556, val_CC_maskV_-1.0=0.46927041, val_MSE_maskV_-1.0=0.82079148, learning_rate=0.001\n", + "Epoch 154/161 - loss=0.71085006, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53732264, MSE_maskV_-1.0=0.71049523, val_loss=0.82542676, val_CC_maskV_-1.0=0.46927661, val_MSE_maskV_-1.0=0.82146358, learning_rate=0.001\n", + "Epoch 161/161 - loss=0.70995456, R2_maskV_-1.0=val_R2_maskV_-1.0=-inf, CC_maskV_-1.0=0.53873634, MSE_maskV_-1.0=0.71001661, val_loss=0.82391202, val_CC_maskV_-1.0=0.46978387, val_MSE_maskV_-1.0=0.82019931, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-30 16:55:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 42.45s\n", + "\u001b[32m2025-05-30 16:55:48\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.81590313)\n", + "\u001b[32m2025-05-30 16:55:48\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 201 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 806us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:55:49\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_-1.0=0.71, R2_maskV_-1.0=0.289, CC_maskV_-1.0=0.54\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "201/201 [==============================] - 0s 907us/step\n", + "51/51 [==============================] - 0s 851us/step\n", + "84/84 [==============================] - 0s 796us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-30 16:55:50\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 2328] \u001b[1;30mINFO\u001b[0m Saved results for fold 4/4 method \"DPAD_RTR2_uAKCzCy1HL64U_ErSV16\" (16/16) in \"..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4_DPAD_RTR2_uAKCzCy1HL64U_ErSV16_nx16.p\"\n", + "\u001b[32m2025-05-30 16:55:50\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 1948] \u001b[1;30mINFO\u001b[0m Saving results for fold 4 as ..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p.f4_4.p\n", + "\u001b[32m2025-05-30 16:55:51\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 4212] \u001b[1;30mINFO\u001b[0m Saving the results in ..\\..\\..\\results\\8d238f30_683d1f05_N\\DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\\.p\n", + "\u001b[32m2025-05-30 16:55:51\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 4110] \u001b[1;30mINFO\u001b[0m Checking whether result file size could be reduced for future loads\n", + "\u001b[32m2025-05-30 16:55:51\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 4199] \u001b[1;30mINFO\u001b[0m Could not reduce file size\n", + "\u001b[32m2025-05-30 16:55:51\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 320] \u001b[1;30mINFO\u001b[0m Selecting among the 16 tried method variants based on the inner CV results: \n", + "\u001b[32m2025-05-30 16:55:51\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 395] \u001b[1;30mINFO\u001b[0m - Preaveraging CC across the 4 folds => sem will be 0 and will pick the case with best CC\n", + "\u001b[32m2025-05-30 16:55:51\u001b[0m \u001b[34mDPAD.tools.evaluation\u001b[0m [evaluation.py > 569] \u001b[1;30mINFO\u001b[0m Of 16 cases, the following were within 1 sem of the best yCC in each session:\n", + "[13]\n", + "\u001b[32m2025-05-30 16:55:51\u001b[0m \u001b[34mDPAD.tools.evaluation\u001b[0m [evaluation.py > 585] \u001b[1;30mINFO\u001b[0m Criteria 2: CC\n", + "Of 16 cases, the following were within 1 sem of the best CC in each session:\n", + "[9]\n", + "\u001b[32m2025-05-30 16:55:51\u001b[0m \u001b[34mDPAD.tools.evaluation\u001b[0m [evaluation.py > 606] \u001b[1;30mINFO\u001b[0m - In 0/1 sessions ([]) some cases satisfied both criteria, will pick among those.\n", + "\u001b[32m2025-05-30 16:55:51\u001b[0m \u001b[34mDPAD.tools.evaluation\u001b[0m [evaluation.py > 613] \u001b[1;30mINFO\u001b[0m - In 1/1 sessions ([0]), no case satisfied both criteria, so will pick the case with best criteria 2 (CC) among those that satisfy criteria 1 (yCC).\n", + "\u001b[32m2025-05-30 16:55:51\u001b[0m \u001b[34mDPAD.tools.flexible\u001b[0m [flexible.py > 425] \u001b[1;30mINFO\u001b[0m Picked the following method after inner CV: (index 13) DPAD_RTR2_ACzCy1HL64U_ErSV16\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "Selected nonlinearity setting for best neural self-prediction: DPAD_RTR2_ACzCy1HL64U_ErSV16\n" + ] + } + ], + "source": [ + "## Step 1.1: Finding optimal nonlinearity (based on self-prediction of y (neural activity):\n", + "# The following function searches over possible nonlinearities and picks the best one based on the training data\n", + "settings = {}\n", + "settings[\"min_cores_to_enable_parallelization\"] = 100 # If fewer than this many cores are available, code will not run with parallelization,\n", + "# set to a large number to disable parallelization\n", + "settings['fit_epochs'] = 2500 # Fitting will stop upon convergence or after at most the specified number of epochs. The default (2500 epochs) is\n", + "\n", + "methodCode_y = \"DPAD_GSUTy_iCVF4_RTR2_uAKCzCy1HL64U_ErSV16\" # Note that here 'GSUT has changed to GSUTy to denote that performance measure for selection is based on prediction of y.\n", + "\n", + "saveDir = os.path.join(\"..\", \"..\", \"..\", \"results\") # Where you want the fitting results to be saved\n", + "\n", + "# This functions needs to be called for each session, fold and state dimension. Here we only run it for fold 1 of session 1 and with fixed state dimensions of nx=n1=16 as an example\n", + "selectedMethodCode_y, iCVRes_y = fitDPADWithFlexibleNonlinearity(\n", + " yTrain, Z=zTrain, nx=nx, n1=n1, settings=settings, methodCode=methodCode_y, saveDir=saveDir)\n", + "\n", + "print(f'\\n\\nSelected nonlinearity setting for best neural self-prediction: {selectedMethodCode_y}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As the last line of the log shows, in this example the optimal nonlinearity giving rise to best neural (y) self-prediction decoding is: `DPAD_RTR2_ACzCy1HL64U_ErSV16` : $A'$, $C_z$ and $C_y$ nonlinear.\n", + "\n", + "We can next redo step 1.2 with this alternative nonlinearity setting to fit one final model for which nonlinearity setting has been selected to yield the best neural self-prediction. Note that even in this case, with this nonlinearity setting, the process of fitting the final model still involves the same optimization steps as before, with the first optimization step optimizing behavior prediction. See the **Supplementary Fig. 1** and **Methods** in the DPAD paper ([Sani et al, 2024](https://doi.org/10.1038/s41593-024-01731-2)) for details of all optimization steps. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-31 11:19:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-31 11:19:00\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-31 11:19:00\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-31 11:19:00\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 16 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-31 11:19:00\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-31 11:19:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 97 (stopped at 112 epochs).\n", + "\u001b[32m2025-05-31 11:19:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/113 - loss=rnn_1step_loss=rnn_1step_mse=1.0863736, rnn_1step_R2_maskV_None=-0.022074725, rnn_1step_CC_maskV_None=0.14823142, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.9472065, val_rnn_1step_R2_maskV_None=-0.04468137, val_rnn_1step_CC_maskV_None=0.3133198, learning_rate=0.001\n", + "Epoch 13/113 - loss=rnn_1step_loss=rnn_1step_mse=0.82843447, rnn_1step_R2_maskV_None=0.15014026, rnn_1step_CC_maskV_None=0.49345523, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.71026784, val_rnn_1step_R2_maskV_None=0.13140497, val_rnn_1step_CC_maskV_None=0.50978214, learning_rate=0.001\n", + "Epoch 25/113 - loss=rnn_1step_loss=rnn_1step_mse=0.58476853, rnn_1step_R2_maskV_None=0.31582507, rnn_1step_CC_maskV_None=0.67926472, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.56003898, val_rnn_1step_R2_maskV_None=0.26153767, val_rnn_1step_CC_maskV_None=0.65223908, learning_rate=0.001\n", + "Epoch 37/113 - loss=rnn_1step_loss=rnn_1step_mse=0.48832023, rnn_1step_R2_maskV_None=0.39722252, rnn_1step_CC_maskV_None=0.7405498, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.49202049, val_rnn_1step_R2_maskV_None=0.32762149, val_rnn_1step_CC_maskV_None=0.70316976, learning_rate=0.001\n", + "Epoch 49/113 - loss=rnn_1step_loss=rnn_1step_mse=0.44520038, rnn_1step_R2_maskV_None=0.44723606, rnn_1step_CC_maskV_None=0.76662529, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.47435391, val_rnn_1step_R2_maskV_None=0.35051212, val_rnn_1step_CC_maskV_None=0.71791488, learning_rate=0.001\n", + "Epoch 61/113 - loss=rnn_1step_loss=rnn_1step_mse=0.41888779, rnn_1step_R2_maskV_None=0.4794637, rnn_1step_CC_maskV_None=0.78229439, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.45923162, val_rnn_1step_R2_maskV_None=0.36653876, val_rnn_1step_CC_maskV_None=0.73041815, learning_rate=0.001\n", + "Epoch 73/113 - loss=rnn_1step_loss=rnn_1step_mse=0.39820817, rnn_1step_R2_maskV_None=0.50293553, rnn_1step_CC_maskV_None=0.79468268, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.44090655, val_rnn_1step_R2_maskV_None=0.38496274, val_rnn_1step_CC_maskV_None=0.74352872, learning_rate=0.001\n", + "Epoch 85/113 - loss=rnn_1step_loss=rnn_1step_mse=0.38067311, rnn_1step_R2_maskV_None=0.52185482, rnn_1step_CC_maskV_None=0.80508935, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.43021819, val_rnn_1step_R2_maskV_None=0.3990283, val_rnn_1step_CC_maskV_None=0.75106823, learning_rate=0.001\n", + "Epoch 97/113 - loss=rnn_1step_loss=rnn_1step_mse=0.36852929, rnn_1step_R2_maskV_None=0.53580767, rnn_1step_CC_maskV_None=0.81210572, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.42623582, val_rnn_1step_R2_maskV_None=0.40548575, val_rnn_1step_CC_maskV_None=0.75398511, learning_rate=0.001\n", + "Epoch 109/113 - loss=rnn_1step_loss=rnn_1step_mse=0.35994923, rnn_1step_R2_maskV_None=0.54581255, rnn_1step_CC_maskV_None=0.81700861, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.42701548, val_rnn_1step_R2_maskV_None=0.40594915, val_rnn_1step_CC_maskV_None=0.75412607, learning_rate=0.001\n", + "Epoch 113/113 - loss=rnn_1step_loss=rnn_1step_mse=0.35765353, rnn_1step_R2_maskV_None=0.54857695, rnn_1step_CC_maskV_None=0.81832981, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.42677027, val_rnn_1step_R2_maskV_None=0.40652394, val_rnn_1step_CC_maskV_None=0.75436562, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-31 11:19:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 14.25s\n", + "\u001b[32m2025-05-31 11:19:15\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-31 11:19:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 154 (stopped at 169 epochs).\n", + "\u001b[32m2025-05-31 11:19:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/170 - loss=rnn_1_1step_loss=rnn_1_1step_mse=1.0875505, rnn_1_1step_R2_maskV_None=-0.022899967, rnn_1_1step_CC_maskV_None=0.051831119, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.9489007, val_rnn_1_1step_R2_maskV_None=-0.045483753, val_rnn_1_1step_CC_maskV_None=0.26230901, learning_rate=0.001\n", + "Epoch 18/170 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.66149294, rnn_1_1step_R2_maskV_None=0.27124733, rnn_1_1step_CC_maskV_None=0.6300348, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.60225689, val_rnn_1_1step_R2_maskV_None=0.22552511, val_rnn_1_1step_CC_maskV_None=0.60541499, learning_rate=0.001\n", + "Epoch 35/170 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.4826588, rnn_1_1step_R2_maskV_None=0.41496369, rnn_1_1step_CC_maskV_None=0.74382776, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.49160695, val_rnn_1_1step_R2_maskV_None=0.33530661, val_rnn_1_1step_CC_maskV_None=0.70446074, learning_rate=0.001\n", + "Epoch 52/170 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.42765427, rnn_1_1step_R2_maskV_None=0.4743914, rnn_1_1step_CC_maskV_None=0.77708173, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.46061873, val_rnn_1_1step_R2_maskV_None=0.3710832, val_rnn_1_1step_CC_maskV_None=0.72923595, learning_rate=0.001\n", + "Epoch 69/170 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.39964241, rnn_1_1step_R2_maskV_None=0.50508052, rnn_1_1step_CC_maskV_None=0.79375803, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.44425994, val_rnn_1_1step_R2_maskV_None=0.38755661, val_rnn_1_1step_CC_maskV_None=0.74190074, learning_rate=0.001\n", + "Epoch 86/170 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.37749666, rnn_1_1step_R2_maskV_None=0.52824396, rnn_1_1step_CC_maskV_None=0.80678689, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.43046665, val_rnn_1_1step_R2_maskV_None=0.40309161, val_rnn_1_1step_CC_maskV_None=0.75002766, learning_rate=0.001\n", + "Epoch 103/170 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.36241567, rnn_1_1step_R2_maskV_None=0.54525828, rnn_1_1step_CC_maskV_None=0.81555599, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.41856012, val_rnn_1_1step_R2_maskV_None=0.41523129, val_rnn_1_1step_CC_maskV_None=0.75756288, learning_rate=0.001\n", + "Epoch 120/170 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.35176298, rnn_1_1step_R2_maskV_None=0.55843502, rnn_1_1step_CC_maskV_None=0.82165128, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.41395786, val_rnn_1_1step_R2_maskV_None=0.42206502, val_rnn_1_1step_CC_maskV_None=0.76111758, learning_rate=0.001\n", + "Epoch 137/170 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.34227547, rnn_1_1step_R2_maskV_None=0.57131565, rnn_1_1step_CC_maskV_None=0.82698727, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.41165659, val_rnn_1_1step_R2_maskV_None=0.42779666, val_rnn_1_1step_CC_maskV_None=0.76301676, learning_rate=0.001\n", + "Epoch 154/170 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.33344358, rnn_1_1step_R2_maskV_None=0.58403993, rnn_1_1step_CC_maskV_None=0.83173543, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.40888622, val_rnn_1_1step_R2_maskV_None=0.43349284, val_rnn_1_1step_CC_maskV_None=0.76565385, learning_rate=0.001\n", + "Epoch 170/170 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.32500812, rnn_1_1step_R2_maskV_None=0.5972771, rnn_1_1step_CC_maskV_None=0.8367601, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.41581786, val_rnn_1_1step_R2_maskV_None=0.43335277, val_rnn_1_1step_CC_maskV_None=0.76078552, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-31 11:19:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 19.81s\n", + "\u001b[32m2025-05-31 11:19:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.40888622)\n", + "\u001b[32m2025-05-31 11:19:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_None=0.324, R2_maskV_None=0.604, CC_maskV_None=0.838\n", + "\u001b[32m2025-05-31 11:19:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_None=0.393, R2_maskV_None=0.465, CC_maskV_None=0.783\n", + "\u001b[32m2025-05-31 11:19:36\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-31 11:19:36\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-31 11:20:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 69 (stopped at 84 epochs).\n", + "\u001b[32m2025-05-31 11:20:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/85 - loss=mse=1.2406653, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.40742913, val_loss=val_mse=0.98199821, val_CC_maskV_None=0.56472331, learning_rate=0.001\n", + "Epoch 10/85 - loss=mse=0.69143051, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.72276425, val_loss=val_mse=0.70192206, val_CC_maskV_None=0.71455854, learning_rate=0.001\n", + "Epoch 19/85 - loss=mse=0.65526092, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.73948425, val_loss=val_mse=0.67199951, val_CC_maskV_None=0.72883004, learning_rate=0.001\n", + "Epoch 28/85 - loss=mse=0.6443488, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.74464363, val_loss=val_mse=0.67054343, val_CC_maskV_None=0.72953862, learning_rate=0.001\n", + "Epoch 37/85 - loss=mse=0.63787842, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.74731338, val_loss=val_mse=0.66736609, val_CC_maskV_None=0.73084873, learning_rate=0.001\n", + "Epoch 46/85 - loss=mse=0.63244605, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.75019354, val_loss=val_mse=0.66575319, val_CC_maskV_None=0.73180491, learning_rate=0.001\n", + "Epoch 55/85 - loss=mse=0.62795269, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.75195277, val_loss=val_mse=0.66118753, val_CC_maskV_None=0.73394918, learning_rate=0.001\n", + "Epoch 64/85 - loss=mse=0.62473297, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.75365281, val_loss=val_mse=0.65702087, val_CC_maskV_None=0.7360757, learning_rate=0.001\n", + "Epoch 73/85 - loss=mse=0.62258542, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.7548911, val_loss=val_mse=0.65417135, val_CC_maskV_None=0.73721373, learning_rate=0.001\n", + "Epoch 82/85 - loss=mse=0.62066597, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.75563848, val_loss=val_mse=0.65818661, val_CC_maskV_None=0.73540503, learning_rate=0.001\n", + "Epoch 85/85 - loss=mse=0.61977506, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.75583899, val_loss=val_mse=0.65442526, val_CC_maskV_None=0.73689216, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-31 11:20:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 27.89s\n", + "\u001b[32m2025-05-31 11:20:04\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-31 11:20:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 69 (stopped at 84 epochs).\n", + "\u001b[32m2025-05-31 11:20:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/85 - loss=mse=1.2411772, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.4012343, val_loss=val_mse=0.97497523, val_CC_maskV_None=0.56882471, learning_rate=0.001\n", + "Epoch 10/85 - loss=mse=0.69661719, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.72025502, val_loss=val_mse=0.71075237, val_CC_maskV_None=0.71017897, learning_rate=0.001\n", + "Epoch 19/85 - loss=mse=0.65908027, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.73759478, val_loss=val_mse=0.6757741, val_CC_maskV_None=0.726861, learning_rate=0.001\n", + "Epoch 28/85 - loss=mse=0.64594066, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.74394584, val_loss=val_mse=0.67221951, val_CC_maskV_None=0.72854525, learning_rate=0.001\n", + "Epoch 37/85 - loss=mse=0.63782287, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.7473774, val_loss=val_mse=0.66621554, val_CC_maskV_None=0.73140538, learning_rate=0.001\n", + "Epoch 46/85 - loss=mse=0.63179797, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.75032198, val_loss=val_mse=0.66532153, val_CC_maskV_None=0.73203731, learning_rate=0.001\n", + "Epoch 55/85 - loss=mse=0.62709618, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.75229877, val_loss=val_mse=0.66003573, val_CC_maskV_None=0.73461765, learning_rate=0.001\n", + "Epoch 64/85 - loss=mse=0.62349957, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.75428379, val_loss=val_mse=0.65520781, val_CC_maskV_None=0.73701137, learning_rate=0.001\n", + "Epoch 73/85 - loss=mse=0.62125576, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.75548238, val_loss=val_mse=0.65535766, val_CC_maskV_None=0.73685938, learning_rate=0.001\n", + "Epoch 82/85 - loss=mse=0.6195066, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.75608134, val_loss=val_mse=0.65777326, val_CC_maskV_None=0.73575562, learning_rate=0.001\n", + "Epoch 85/85 - loss=mse=0.61866266, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.75617069, val_loss=val_mse=0.65421468, val_CC_maskV_None=0.73715007, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-31 11:20:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 27.83s\n", + "\u001b[32m2025-05-31 11:20:32\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 2/2, which had the smallest loss (0.65167236)\n", + "\u001b[32m2025-05-31 11:20:32\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 268 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "268/268 [==============================] - 0s 739us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-31 11:20:33\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_None=0.619, R2_maskV_None=0.386, CC_maskV_None=0.758\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "268/268 [==============================] - 0s 775us/step\n", + "67/67 [==============================] - 0s 816us/step\n" + ] + } + ], + "source": [ + "## Step 1.2: Fitting DPAD with optimal nonlinearity\n", + "## or \n", + "## simply running DPAD with user-defined nonlinearity\n", + "\n", + "# ATTENTION: To complete the flexible DPAD, you need to first run the previous cell and pass methodCode=selectedMethodCode_y this section:\n", + "methodCode_y = selectedMethodCode_y # The methodCode selected by the run above that selects nonlinearity for best neural self-prediction\n", + "\n", + "idSysF_y = DPADModel()\n", + "epochs = 2500 # Default for this is 2500.\n", + "# Fitting will stop upon convergence or after at most the specified number of\n", + "# epochs. 2500 as the max number of epochs is usually more than enough.\n", + "# In addition, the `ErSV16` in the method code enables early stopping based on validation loss. \n", + "# This means that learning can stop even before 2500 epochs, as soon as the loss for validation data \n", + "# (last 20% of training data) doesn't improve for 16 epochs (`ErSV16`). After early stopping\n", + "# the model from the epoch with the best validation loss (which is not going to be the last epoch)\n", + "# is taken as the final learned model.\n", + "\n", + "# Prepare settings to make desired parameters in the learned model nonlinear\n", + "args_y = DPADModel.prepare_args(methodCode_y)\n", + "idSysF_y.fit(yTrain.T, Z=zTrain.T, nx=nx, n1=n1, epochs=epochs, **args_y)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing predictions for the learned model with optimal nonlinearity for neural self-prediction\n", + "84/84 [==============================] - 0s 607us/step\n", + "Neural self-prediction CC:\n", + " Nonlinear DPAD (Flexible; best nonlinearity for self-prediction) => 0.558\n" + ] + } + ], + "source": [ + "# Predict behavior and neural activity, from past neural activity, using the learned model\n", + "print(\"Computing predictions for the learned model with optimal nonlinearity for neural self-prediction\")\n", + "###########\n", + "zTestPredF_y, yTestPredF_y, xTestPredF_y = idSysF_y.predict(yTest)\n", + "\n", + "# Compute CC of decoding and self-prediction\n", + "zCCNonLinF_y = evalPrediction(zTest, zTestPredF_y, \"CC\")\n", + "yCCNonLinF_y = evalPrediction(yTest, yTestPredF_y, \"CC\")\n", + "##########\n", + "\n", + "\n", + "print(\n", + " f\"Neural self-prediction CC:\\n Nonlinear DPAD (Flexible; best nonlinearity for self-prediction) => {np.mean(yCCNonLinF_y):.3g}\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Comparison to a fully linear DPAD model\n", + "\n", + "After seeing how DPAD performs, we run a special case of DPAD that is fully **linear** and compare its performance to the nonlinear DPAD we ran above.\n", + "\n", + "Running linear DPAD on the same data:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-31 11:28:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 907] \u001b[1;30mINFO\u001b[0m Early stopping measure is \"val_loss\". Includes validation loss, so we will ignore any provided validation data and creating validation data fom the training data to avoid overfitting\n", + "\u001b[32m2025-05-31 11:28:55\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1525] \u001b[1;30mINFO\u001b[0m Stage 1: Learning A11, K1, Cz1 (ZType: cont)\n", + "\u001b[32m2025-05-31 11:28:55\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1583] \u001b[1;30mINFO\u001b[0m Shifting output by 1 samples to train network for 1-step ahead prediction\n", + "\u001b[32m2025-05-31 11:28:55\u001b[0m \u001b[34mDPAD.RNNModel\u001b[0m [RNNModel.py > 1743] \u001b[1;30mINFO\u001b[0m Have 4 batches each with 16 128-sample data segments (ny_in=46, ny_out=4, nft=0)\n", + "\u001b[32m2025-05-31 11:28:55\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-31 11:29:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 99 (stopped at 114 epochs).\n", + "\u001b[32m2025-05-31 11:29:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/115 - loss=rnn_1step_loss=rnn_1step_mse=1.0884688, rnn_1step_R2_maskV_None=-0.023391459, rnn_1step_CC_maskV_None=0.0027947305, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.94051683, val_rnn_1step_R2_maskV_None=-0.0380086, val_rnn_1step_CC_maskV_None=0.22022103, learning_rate=0.001\n", + "Epoch 13/115 - loss=rnn_1step_loss=rnn_1step_mse=0.78423607, rnn_1step_R2_maskV_None=0.19845749, rnn_1step_CC_maskV_None=0.53056878, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.67343658, val_rnn_1step_R2_maskV_None=0.17276062, val_rnn_1step_CC_maskV_None=0.54554749, learning_rate=0.001\n", + "Epoch 25/115 - loss=rnn_1step_loss=rnn_1step_mse=0.60954881, rnn_1step_R2_maskV_None=0.34736848, rnn_1step_CC_maskV_None=0.66120863, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.59472841, val_rnn_1step_R2_maskV_None=0.25113946, val_rnn_1step_CC_maskV_None=0.62839419, learning_rate=0.001\n", + "Epoch 37/115 - loss=rnn_1step_loss=rnn_1step_mse=0.56603241, rnn_1step_R2_maskV_None=0.3939791, rnn_1step_CC_maskV_None=0.69047248, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.56940138, val_rnn_1step_R2_maskV_None=0.27840409, val_rnn_1step_CC_maskV_None=0.65268117, learning_rate=0.001\n", + "Epoch 49/115 - loss=rnn_1step_loss=rnn_1step_mse=0.54068953, rnn_1step_R2_maskV_None=0.4164961, rnn_1step_CC_maskV_None=0.70716679, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.54985195, val_rnn_1step_R2_maskV_None=0.29828644, val_rnn_1step_CC_maskV_None=0.66975552, learning_rate=0.001\n", + "Epoch 61/115 - loss=rnn_1step_loss=rnn_1step_mse=0.5207001, rnn_1step_R2_maskV_None=0.43565843, rnn_1step_CC_maskV_None=0.72005081, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.53450519, val_rnn_1step_R2_maskV_None=0.31671804, val_rnn_1step_CC_maskV_None=0.68206704, learning_rate=0.001\n", + "Epoch 73/115 - loss=rnn_1step_loss=rnn_1step_mse=0.50263351, rnn_1step_R2_maskV_None=0.45635507, rnn_1step_CC_maskV_None=0.73140091, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.5214324, val_rnn_1step_R2_maskV_None=0.33328182, val_rnn_1step_CC_maskV_None=0.69172132, learning_rate=0.001\n", + "Epoch 85/115 - loss=rnn_1step_loss=rnn_1step_mse=0.48855814, rnn_1step_R2_maskV_None=0.4773252, rnn_1step_CC_maskV_None=0.74001527, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.51183391, val_rnn_1step_R2_maskV_None=0.34556508, val_rnn_1step_CC_maskV_None=0.69838655, learning_rate=0.001\n", + "Epoch 97/115 - loss=rnn_1step_loss=rnn_1step_mse=0.4755066, rnn_1step_R2_maskV_None=0.50301683, rnn_1step_CC_maskV_None=0.74770474, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.50580537, val_rnn_1step_R2_maskV_None=0.35389718, val_rnn_1step_CC_maskV_None=0.70300543, learning_rate=0.001\n", + "Epoch 109/115 - loss=rnn_1step_loss=rnn_1step_mse=0.4641152, rnn_1step_R2_maskV_None=0.52202427, rnn_1step_CC_maskV_None=0.75464749, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.50784802, val_rnn_1step_R2_maskV_None=0.34850293, val_rnn_1step_CC_maskV_None=0.70282686, learning_rate=0.001\n", + "Epoch 115/115 - loss=rnn_1step_loss=rnn_1step_mse=0.46074754, rnn_1step_R2_maskV_None=0.52530748, rnn_1step_CC_maskV_None=0.75679648, val_loss=val_rnn_1step_loss=val_rnn_1step_mse=0.50896919, val_rnn_1step_R2_maskV_None=0.34615028, val_rnn_1step_CC_maskV_None=0.70249295, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-31 11:29:06\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 11.09s\n", + "\u001b[32m2025-05-31 11:29:07\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-31 11:29:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 104 (stopped at 119 epochs).\n", + "\u001b[32m2025-05-31 11:29:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/120 - loss=rnn_1_1step_loss=rnn_1_1step_mse=1.0944687, rnn_1_1step_R2_maskV_None=-0.030702427, rnn_1_1step_CC_maskV_None=-0.089731745, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.95215571, val_rnn_1_1step_R2_maskV_None=-0.05088681, val_rnn_1_1step_CC_maskV_None=0.0094655612, learning_rate=0.001\n", + "Epoch 13/120 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.80956638, rnn_1_1step_R2_maskV_None=0.19614816, rnn_1_1step_CC_maskV_None=0.53742409, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.70858574, val_rnn_1_1step_R2_maskV_None=0.16170996, val_rnn_1_1step_CC_maskV_None=0.5159725, learning_rate=0.001\n", + "Epoch 25/120 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.60160398, rnn_1_1step_R2_maskV_None=0.36223769, rnn_1_1step_CC_maskV_None=0.66693449, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.59548402, val_rnn_1_1step_R2_maskV_None=0.25493276, val_rnn_1_1step_CC_maskV_None=0.63164812, learning_rate=0.001\n", + "Epoch 37/120 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.56678176, rnn_1_1step_R2_maskV_None=0.3964242, rnn_1_1step_CC_maskV_None=0.69000143, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.57295114, val_rnn_1_1step_R2_maskV_None=0.27520847, val_rnn_1_1step_CC_maskV_None=0.65034521, learning_rate=0.001\n", + "Epoch 49/120 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.54585779, rnn_1_1step_R2_maskV_None=0.41278884, rnn_1_1step_CC_maskV_None=0.70380121, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.55546254, val_rnn_1_1step_R2_maskV_None=0.29266232, val_rnn_1_1step_CC_maskV_None=0.66503578, learning_rate=0.001\n", + "Epoch 61/120 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.52582812, rnn_1_1step_R2_maskV_None=0.42957515, rnn_1_1step_CC_maskV_None=0.7167964, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.5393303, val_rnn_1_1step_R2_maskV_None=0.31087759, val_rnn_1_1step_CC_maskV_None=0.67825836, learning_rate=0.001\n", + "Epoch 73/120 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.50841063, rnn_1_1step_R2_maskV_None=0.44881794, rnn_1_1step_CC_maskV_None=0.72786295, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.52813935, val_rnn_1_1step_R2_maskV_None=0.32550615, val_rnn_1_1step_CC_maskV_None=0.68662369, learning_rate=0.001\n", + "Epoch 85/120 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.49671203, rnn_1_1step_R2_maskV_None=0.4678019, rnn_1_1step_CC_maskV_None=0.73508477, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.52133119, val_rnn_1_1step_R2_maskV_None=0.33450571, val_rnn_1_1step_CC_maskV_None=0.69089276, learning_rate=0.001\n", + "Epoch 97/120 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.48629582, rnn_1_1step_R2_maskV_None=0.48888165, rnn_1_1step_CC_maskV_None=0.7412861, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.51550537, val_rnn_1_1step_R2_maskV_None=0.34172952, val_rnn_1_1step_CC_maskV_None=0.69490224, learning_rate=0.001\n", + "Epoch 109/120 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.47690886, rnn_1_1step_R2_maskV_None=0.5072611, rnn_1_1step_CC_maskV_None=0.7469337, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.51414061, val_rnn_1_1step_R2_maskV_None=0.34110922, val_rnn_1_1step_CC_maskV_None=0.69659072, learning_rate=0.001\n", + "Epoch 120/120 - loss=rnn_1_1step_loss=rnn_1_1step_mse=0.47172707, rnn_1_1step_R2_maskV_None=0.51249176, rnn_1_1step_CC_maskV_None=0.75023586, val_loss=val_rnn_1_1step_loss=val_rnn_1_1step_mse=0.51415855, val_rnn_1_1step_R2_maskV_None=0.33863798, val_rnn_1_1step_CC_maskV_None=0.69739592, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-31 11:29:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 11.30s\n", + "\u001b[32m2025-05-31 11:29:18\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.50569403)\n", + "\u001b[32m2025-05-31 11:29:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1557] \u001b[1;30mINFO\u001b[0m Training Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_None=0.448, R2_maskV_None=0.551, CC_maskV_None=0.767\n", + "\u001b[32m2025-05-31 11:29:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1580] \u001b[1;30mINFO\u001b[0m Validation Z pred after fitting RNN1: \n", + "1-step: MSE_maskV_None=0.497, R2_maskV_None=0.385, CC_maskV_None=0.72\n", + "\u001b[32m2025-05-31 11:29:19\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1659] \u001b[1;30mINFO\u001b[0m Stage 1: Learning Cy1 (YType: cont)\n", + "\u001b[32m2025-05-31 11:29:19\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 1 of 2\n", + "\u001b[32m2025-05-31 11:30:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 237 (stopped at 252 epochs).\n", + "\u001b[32m2025-05-31 11:30:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/253 - loss=mse=1.8871212, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.16628735, val_loss=val_mse=1.3161354, val_CC_maskV_None=0.30559605, learning_rate=0.001\n", + "Epoch 27/253 - loss=mse=0.8897211, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.62926334, val_loss=val_mse=0.87957698, val_CC_maskV_None=0.63068008, learning_rate=0.001\n", + "Epoch 53/253 - loss=mse=0.82096243, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.66063267, val_loss=val_mse=0.8116098, val_CC_maskV_None=0.66333622, learning_rate=0.001\n", + "Epoch 79/253 - loss=mse=0.79547638, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.67230135, val_loss=val_mse=0.78426325, val_CC_maskV_None=0.67639166, learning_rate=0.001\n", + "Epoch 105/253 - loss=mse=0.78294438, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.67851084, val_loss=val_mse=0.77325505, val_CC_maskV_None=0.68075198, learning_rate=0.001\n", + "Epoch 131/253 - loss=mse=0.7762078, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.68139106, val_loss=val_mse=0.76685196, val_CC_maskV_None=0.68380052, learning_rate=0.001\n", + "Epoch 157/253 - loss=mse=0.77198088, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.68356919, val_loss=val_mse=0.7649042, val_CC_maskV_None=0.6847477, learning_rate=0.001\n", + "Epoch 183/253 - loss=mse=0.76913452, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.68525988, val_loss=val_mse=0.76202112, val_CC_maskV_None=0.68591446, learning_rate=0.001\n", + "Epoch 209/253 - loss=mse=0.76755959, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.68469858, val_loss=val_mse=0.76183033, val_CC_maskV_None=0.68635839, learning_rate=0.001\n", + "Epoch 235/253 - loss=mse=0.76624852, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.68621528, val_loss=val_mse=0.75788909, val_CC_maskV_None=0.68804353, learning_rate=0.001\n", + "Epoch 253/253 - loss=mse=0.76566017, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.68598258, val_loss=val_mse=0.758048, val_CC_maskV_None=0.68807846, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-31 11:30:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 75.88s\n", + "\u001b[32m2025-05-31 11:30:35\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 226] \u001b[1;30mINFO\u001b[0m Starting fit attempt 2 of 2\n", + "\u001b[32m2025-05-31 11:31:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 114] \u001b[1;30mINFO\u001b[0m Restoring model weights from the end of the best epoch: 237 (stopped at 252 epochs).\n", + "\u001b[32m2025-05-31 11:31:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 499] \u001b[1;30mINFO\u001b[0m \n", + "Epoch 1/253 - loss=mse=1.9092494, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.085909136, val_loss=val_mse=1.3774902, val_CC_maskV_None=0.23793884, learning_rate=0.001\n", + "Epoch 27/253 - loss=mse=0.89659345, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.62550622, val_loss=val_mse=0.88803905, val_CC_maskV_None=0.62592679, learning_rate=0.001\n", + "Epoch 53/253 - loss=mse=0.82346183, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.65946597, val_loss=val_mse=0.81485665, val_CC_maskV_None=0.66163951, learning_rate=0.001\n", + "Epoch 79/253 - loss=mse=0.79656655, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.67182791, val_loss=val_mse=0.78571165, val_CC_maskV_None=0.67564327, learning_rate=0.001\n", + "Epoch 105/253 - loss=mse=0.78349847, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.67826122, val_loss=val_mse=0.77404612, val_CC_maskV_None=0.68031502, learning_rate=0.001\n", + "Epoch 131/253 - loss=mse=0.7765395, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.68125194, val_loss=val_mse=0.76730824, val_CC_maskV_None=0.68352413, learning_rate=0.001\n", + "Epoch 157/253 - loss=mse=0.77219826, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.68346488, val_loss=val_mse=0.76520365, val_CC_maskV_None=0.68455756, learning_rate=0.001\n", + "Epoch 183/253 - loss=mse=0.76928675, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.6851781, val_loss=val_mse=0.76224113, val_CC_maskV_None=0.68577141, learning_rate=0.001\n", + "Epoch 209/253 - loss=mse=0.76766658, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.6846503, val_loss=val_mse=0.76197171, val_CC_maskV_None=0.68626201, learning_rate=0.001\n", + "Epoch 235/253 - loss=mse=0.76632589, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.68617696, val_loss=val_mse=0.75801748, val_CC_maskV_None=0.68795753, learning_rate=0.001\n", + "Epoch 253/253 - loss=mse=0.76572371, R2_maskV_None=val_R2_maskV_None=-inf, CC_maskV_None=0.68595409, val_loss=val_mse=0.7581557, val_CC_maskV_None=0.68800706, learning_rate=0.001\n", + "\n", + "\u001b[32m2025-05-31 11:31:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 539] \u001b[1;30mINFO\u001b[0m Model fitting took 75.33s\n", + "\u001b[32m2025-05-31 11:31:50\u001b[0m \u001b[34mDPAD.tools.model_base_classes\u001b[0m [model_base_classes.py > 584] \u001b[1;30mINFO\u001b[0m Selected model from learning attempt 1/2, which had the smallest loss (0.75590074)\n", + "\u001b[32m2025-05-31 11:31:50\u001b[0m \u001b[34mDPAD.RegressionModel\u001b[0m [RegressionModel.py > 470] \u001b[1;30mINFO\u001b[0m Model fitting finished. Had 268 batches each with batch_size of 31 samples each (ny_in=16, ny_out=46)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "268/268 [==============================] - 0s 812us/step\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2025-05-31 11:31:51\u001b[0m \u001b[34mDPAD.DPADModel\u001b[0m [DPADModel.py > 1712] \u001b[1;30mINFO\u001b[0m Training Y pred after fitting model1_Cy: \n", + "1-step: MSE_maskV_None=0.765, R2_maskV_None=0.289, CC_maskV_None=0.688\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "268/268 [==============================] - 0s 699us/step\n", + "67/67 [==============================] - 0s 606us/step\n" + ] + } + ], + "source": [ + "# Linear DPAD\n", + "methodCode = 'DPAD_RTR2_ErSV16' \n", + "# Notice that we still have `RTR2` (2 reties with different initialization) and `ErSV16` (early stopping based on validation data) in the method code.\n", + "# These two are generally good optimization settings to have, regardless of nonlinearity or linearity of the model.\n", + "\n", + "idSysLin = DPADModel()\n", + "epochs = 2500 # Default for this is 2500.\n", + "\n", + "# Prepare settings to make desired parameters in the learned model nonlinear\n", + "args = DPADModel.prepare_args(methodCode)\n", + "idSysLin.fit(yTrain.T, Z=zTrain.T, nx=nx, n1=n1, epochs=epochs, **args)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(
, )" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "idSysLin.plot_logs() # Plotting loss curves for fully linear DPAD" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We then run inference with learned linear model:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing predictions for the learned linear model\n", + "84/84 [==============================] - 0s 692us/step\n", + "Behavior decoding CC:\n", + " linear DPAD => 0.676\n", + "Neural self-prediction CC:\n", + " linear DPAD => 0.495\n" + ] + } + ], + "source": [ + "# Predict behavior and neural activity, from past neural activity, using the learned model\n", + "print(\"Computing predictions for the learned linear model\")\n", + "zTestPredLin, yTestPredLin, xTestPredLin = idSysLin.predict(yTest)\n", + "\n", + "# Compute CC of decoding and self-prediction\n", + "zCCLin = evalPrediction(zTest, zTestPredLin, \"CC\")\n", + "yCCLin = evalPrediction(yTest, yTestPredLin, \"CC\")\n", + "\n", + "print(\n", + " f\"Behavior decoding CC:\\n linear DPAD => {np.mean(zCCLin):.3g}\"\n", + ")\n", + "print(\n", + " f\"Neural self-prediction CC:\\n linear DPAD => {np.mean(yCCLin):.3g}\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# Let's plot the prediction performance\n", + "def plotDecoding(zCCVals, labels, cols, zPerfMeasure=\"CC\", title='Behavior decoding', ax=None, figsize=(4, 4)):\n", + " if ax is None:\n", + " fig = plt.figure(figsize=figsize)\n", + " ax = fig.add_subplot(1, 1, 1)\n", + " prepAxesStyle(ax)\n", + " # Make bar plot of zCC values\n", + " barlist = ax.bar(np.arange(len(zCCVals)), zCCVals, alpha=0.5)\n", + " ax.set_xticks(np.arange(len(zCCVals)))\n", + " ax.set_xticklabels([L.replace(\"_\", \"\\n\") for L in labels])\n", + " for mi in range(len(barlist)):\n", + " barlist[mi].set_color(cols[mi])\n", + " ax.set_ylabel(f\"{title} {zPerfMeasure}\", fontsize=14)\n", + " ax.set_xlabel(\"\", fontsize=14)\n", + " ax.set_title(title, fontsize=14)\n", + " ax.tick_params(axis=\"both\", labelsize=14)\n", + " if ax is None:\n", + " plt.show()\n", + "\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "zCCValsL = [np.mean(zCCNonLinF), np.mean(zCCLin)] # Compute average CC across z dimensions\n", + "yCCValsL = [np.mean(yCCNonLinF_y), np.mean(yCCLin)] # Compute average CC across y dimensions\n", + "labelsL1 = [\"Flexible DPAD\\n(best behavior decoding)\", \"Linear DPAD\"]\n", + "labelsL2 = [\"Flexible DPAD\\n(best neural self-prediction)\", \"Linear DPAD\"]\n", + "colsL = [\"#1d5925\", \"#39b54a\"]\n", + "plotDecoding(zCCValsL, labelsL1, colsL, zPerfMeasure=\"CC\", title='Behavior decoding', ax=None, figsize=(4, 4))\n", + "plotDecoding(yCCValsL, labelsL2, colsL, zPerfMeasure=\"CC\", title='Neural self-prediction', ax=None, figsize=(4, 4))\n", + "\n", + "# plotDecodingAndSelfPred(zCCValsL, yCCValsL, labelsL, colsL)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that both when the goal is behavior decoding (top), and when the goal is neural self-prediciton (bottom), nonlinear DPAD is outperforming linear DPAD. \n", + "\n", + "**Note**: As noted earlier, \"Flexible DPAD (best neural self-prediction)\" is still optimizing behavior decoding in its first optimizatin step, and the only reason we call it (\"best neural self-prediction\") is that the metric used to select the nonlinearity setting is the neural self-prediction. If one is interested in only optimizing neural self-prediction, at the expense of behavior decoding, then a special case of DPAD, which we can NDM can be used, where we set `n1=0` to skip the first and second optimization steps and learn all latent states using the 3rd and 4th optimization steps. See the **Supplementary Fig. 1** and **Methods** in the DPAD paper ([Sani et al, 2024](https://doi.org/10.1038/s41593-024-01731-2)) for details of all optimization steps. NDM loses much of the capabilities of DPAD because it no longer optimizes behavior, so in the interest of not causing any confusion, we will not include a full demo of NDM here. We have however included some examples with NDM in simulation in our other Notebook on DPAD ([DPAD_tutorial.ipynb](https://github.dev/ShanechiLab/DPAD/blob/main/source/DPAD/example/DPAD_tutorial.ipynb))." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".new_venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.0" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +}