dataloader | generic utility to be used as part of your application | Batch Processing library

TL;DR use nn.ModuleList instead of a pythonic one to store the hidden layers in Net.

All your hidden layers are stored in a simple pythonic list self.hidden in Net. When you move your model to GPU, using .to(device), pytorch has no way to tell that all the elements of this pythonic list should also be moved to the same device. however, if you make self.hidden = nn.ModuleLis(), pytorch now knows to treat all elements of this special list as nn.Modules and recursively move them to the same device as Net.

See these answers 1, 2, 3 for more details.

Since ImageFolderWithPaths inherits from datasets.ImageFolder as shown in the code from GitHub and datasets.ImageFolder has the following arguments including transform: (see here for more info)

torchvision.datasets.ImageFolder(root: str, transform: Optional[Callable] = None, target_transform: Optional[Callable] = None, loader: Callable[[str], Any] = , is_valid_file: Optional[Callable[[str], bool]] = None)

Solution: you can use your transformations directly when you instantiate ImageFolderWithPaths.

The sentence means that a DataLoader can be used to iterate the contents of a Dataset. For example, if you've got a Dataset of 1000 images, you can iterate certain attributes in the order that they've been stored in the Dataset and nothing else by itself. In the other hand, a DataLoader that wraps that Dataset allows you to iterate the data in batches, shuffle the data, apply functions, sample data, etc. Just checkout the Pytorch docs on torch.utils.data.DataLoader and you'll see all of the options included.

Based on the paper you shared, it looks like you need to change the weight arrays per each output neuron per each layer. Unfortunately, this means that the implementation of your optimization routine is going to depend on the layer type, since an "output neuron" for a convolution layer is quite different than a fully-connected layer. In other words, just looping over Flux.params(model) is not going to be sufficient, since this is just a set of all the weight arrays in the model and each weight array is treated differently depending on which layer it comes from.

Fortunately, Julia's multiple dispatch does make this easier to write if you use separate functions instead of a giant loop. I'll summarize the algorithm using the pseudo-code below:

Save tensors

First you need to create blob file in case of active storage.

1. To shorten the training process by simply stopping the training for loop after a certain number like so.

This is because you are using the @EqualsAndHashCode Lombok annotation. There is an error (possibly recursive, since your stack trace is large, I am not sure) when getting the hashcode of the Review JPA entity.

The Lombok auto-generated hashcode method in Review entity will call the Book entity, which tries to get the hashcode of the Set of Reviews. This Set needs to be initialized first before it can be read.

There is no error actually.

The problem is that your config specifies the maximum iteration as 16000.