The torsk from nmheim

Suggestion: Make parameters a dict

It's a bit awkward to address every parameter by name, as is needed when represented as fields in an object. For example, updating parameter values on the command line is much easier, if I could do

def update_params(params,args):
    for i in range(1,len(args),2):
        [key,value] = args[i:i+2];
        params[key] = eval(value)

Then the default values can sit in the json file, but it's quick to supply alternate values without having to change the json or source code.

Keep/calculate shapes in input maps, use in debug/visualization

Currently input maps forget their shapes after being flattened, making plot_iteration need to guess a nice square. Better to keep the natural shape and use that for plotting.

Pad prediction area (input_image) with true data "frame"

Use online least squares for sliding window optimization

maybe add forgetting to internal states?

do some actual anomaly detection on kuroshio!

Simple pure-numpy implemenation of sparse matrices w/ fixed number of nonzeros per row

Something along these lines:

class sparse_matrix_from_dense():
    def __init__(self,Adense,nz_per_row):
        self.ix_row, self.ix_col = np.nonzero(Adense);
        self.nz_per_row = nz_per_row
        self.values = Adense[self.ix_row,self.ix_col]
        
class sparse_matrix():
    def __init__(self,values,nz_per_row,ix_row,ix_col):
        self.values = values
        self.nz_per_row = nz_per_row
        self.ix_row = ix_row
        self.ix_col = ix_col
        
def sparse_dense_mm(A,X):
    AXv = A.values[:,None]*X[A.ix_col,:];
    return np.sum(AXv.reshape((-1,X.shape[1],A.nz_per_row))
                  
def sparse_dense_mv(A,x):
    Axv = A.values[:]*x[A.ix_col];
    return np.sum(Axv.reshape((-1,A.nz_per_row))

Feature request: Input map sequence, or rescaling parameter

Whenever we add a convolutional map, or another image transformation, we get a full multiple of the input image size added to the hidden variables. That quickly becomes very large.

Would like the possibility to downsample after applying the map, so that more features can be included without blowing up the size of the hidden space too much.

Efficient G-weighted least squares

Store git hash and command line in all generated .nc-files

To make reproducibility a thing, we need to couple output with how it was generated. Since the software is a moving target, we both need the commit ID and the command line used to run the code.

The command line is just sys.argv; the git commit we need to read from .git (possibly on pip install -e, stored as a variable).

Get same prediciton quality as tensorflow torsk

So far the data was not normalized... is that the reason the predictions are not that good?

find a way to balance mean amplitude of contributions to state by different input maps (pixel/conv/previous state/...)

`TorchImageDataset` broken

Traceback (most recent call last):
  File "run.py", line 66, in <module>
    steps=1, step_length=2)
  File "/home/niklas/repos/toto/torsk/__init__.py", line 243, in train_predict_esn
    inputs, labels, pred_labels = dataset[idx]
  File "/home/niklas/repos/toto/torsk/data/torch_dataset.py", line 45, in __getitem__
    images = self._images[
AttributeError: 'TorchImageDataset' object has no attribute '_images'

ensure values from -1 to 1 in datasets

Automatic removal of annual cycles

If an underlying periodicity is known a priori in the input data (as in many Earth-science datasets with a yearly cycle), it should be possible to specify the period length and ask us to automatically remove the average cycle before training.

This could either be done:

off-line as a preprocessing step (together with e.g. scaling and cosine transform), or
in the loader.
In both cases, the average cycle is stored, and can be added back before displaying the result.

In the ocean data, the annual cycle is very clear in the cosine-transformed coefficients (less so in the pixel values).

In cases where the annual cycle is very dominant, this means that the NN doesn't need to spend its efforts reproducing it, possibly leading to missing the more subtle details that we're after.

Similarly, the (linear or quadratic) trend can be factored out of the data.

Repeated prediction/correction

Needed feature: Predict a shorter distance into the future, then retrain (or feed truth) to increment time, then predict again, etc.

pass only Params to datasets

to reduce arguments

Circle-example differentiates between up-down and left-right

This indicates a bug in the input mapping.

To reproduce: set weights to zero, and replace
x, y = np.sin(t), np.cos(0.25 * t)
by
x, y = np.sin(0.25 * t), np.cos(t)
in cirle/run.py

write_video is broken somehow

libavfile complains about receiving fewer bytes than it asks for.

Dense ESN gets NotImplementedError from RNNTanhCell with updated PyTorch

PyTorch 1.0: start using `torch.jit.script_method` on forward functions

Tutorial that might be useful: here

Basically this has to be done:

To use script mode, be sure to inherit from the the torch.jit.ScriptModule base class (instead of torch.nn.Module) and add a torch.jit.script decorator to your Python function or a torch.jit.script_method decorator to your module’s methods.

scipy pseudo inverse

is there a difference between pytorch and scipy pseudo inverse

dump model/state/output to file

Reservoir analysis

Check how ESN performance depends on condition number/rank of reservoir.
Compare that to performance of reservoirs that are created from the identity matrix/diagonal matrix with appropriate eigenvalues to which a random unitary transformation is applied.

Find good metric for prediction quality in 2D system

Associated problem: Detect when prediction quality begins to suck (complication: don't confuse with anomaly).

Add time-component to IMED

Due to the large dimensionality along the t-axis, make G_t banded (possibly even tridiagonal), corresponding to limiting the "smearing" along the t-axis to nearby times.

Tridiagonal: correlates only one step ahead and one back. Probably we want a few more steps.

Add Bohrium support

TODO:

imed.py (turn imed_loss back on in test_run_kuro.py and test_run_mackey_2d.py
make it usable with params.backen = 'bohrium'
bohrium 2D convolutions?

input convolution/frequencies

Moving circle

Write moving circle input dataset

run on GPU

Add a sparse ESN implementation

Add feature to write video

Matplotlib is horrifically slow, and interpolates the data whether we want it or not. Would like to just write the actual pixels to video.

Add convolutional distance/loss function

compare 3d IMED to the euclidean difference of blurred volumes

Publish package on PyPy

what to call it?
make it installable without torch

optionally:
pip install torsk[torch]

Make length scale in IMED adjustable

pinv and pinv-stable

Allow user to choose between stable (but slow) SVD-based pseudoinverse, which guarantees a maximal condition number, and the faster simple least-squares solver.

Deal with land masking

preprocess data with non-uniform FT

Fix variable dtypes

dtype can be changed with the new backend features that will be introduced with #26.
this does not work properly for pytorch at the moment.

Harness spatial information

There are several different ways how to make use of the spatial correlations in the SSH input images:

Convolutional layers (problematic with masked images)
Naive FFT (masked values set to zeros)
Non-uniform FT (masked values can be excluded)
Convolution on fourier-transformed images directly. (Problem: find the conv operator in k-space)

class ImageDataset:
  def __init__(self, ...)

  def to_img(self)

  def to_feature(self, kwargs)
    # can specify: raw pixels, different convs, sct/dct (with weighted coefficients?!)

include time + lat/lon in ssh series

Initial glitch in predictions

Both for DCT / real predicitions there seems to be an initially bad prediction that surprisingly becomes better over time?

nmheim / torsk Goto Github PK

torsk's People

Contributors

Stargazers

Watchers

Forkers

torsk's Issues

Recommend Projects

Recommend Topics

Recommend Org