Thanks! What do you mean with different amounts of outputs?

This is my understanding, but i might be mistaken. In my functions i layout the network architecture. Once the function is called you have to fill in the number of input classes, data dimensions, number of features and the number of output classes. From that moment everything is fixed. The UNET only has one output, an array with the binary segmentation.

The only place where there are multiple output ports is in the loss function, which is well explained in the help of mathematica LossFunction. But these are only used in training.

My approach was to create the neural net with only an Input, the data, and an Output, the segmentation, defined. Only when I start training the net I add the appropriate loss functions which have as input the Output of the net and the ground truth Target for comparison. The loss function it self just outputs a number. You can add as many loss functions as needed and you can even provide a different Target to each. As i understand the training tries to minimize the sum of all the loss functions.

Hope this helps.

Be sure to put it on PackageData:

http://packagedata.net/

will do

Please keep in mind that doing this review is an experiment, and I am hoping to have a positive outcome. I do not mean to intrude, or hijack Martijn's package, and I do respect his choices, whatever those may be.

I am making these comments in the hope to benefit both the developer and the user community.

I also hope that others will spontaneously comment on my own work in a similar manner!

Due to lack of time, the below observations will be a bit superficial. I might try to dive deeper later.

init.m

Kernel/init.m is run when $Context is still Global`. Any non-System symbols you use in this file will pollute the Global namespace. Try to avoid this. When the package gets loaded, it should not create any symbols in Global.

I have seen the following update of the context path multiple times:

$ContextPath = Union[$ContextPath, System`$UNETContextPaths];

Note that this reorders the context path!! That includes not having System and Global at the very end, where they should be.

Please don't do this. It will cause unexpected and hard to track down problems for your users.

I noticed that all symbol names are Removed at the start. Maybe I am missing something, but such drastic measures are not usually necessary. ClearAll will do fine.

Note that constructs like ClearAll["foo`*"] or Protect["foo`*"] do work. SetAttributes["foo`*", ReadProtected] does not work, but SetAttributes[Evaluate@Names["foo`*"], ReadProtected] does. Note that none of these constructs introduce any new symbols, thus they are convenient to use in init.m.

Consider not printing anything during package loading without good reason. Note that people might load the package as part of another package. They might even load it on subkernels.

(I do believe that sometimes there is a practical reason. I do it with my IGraph/M package, though I suppress printing when I can detect that IGraph/M is loaded as part of another package. I keep the printed message as small as possible, yet some users still complain about it. It can be suppressed with Block[{Print}, Needs["..."]])

Usage messages

I wanted to note that it's great that you took care to make them work well with auto-completion.

Miscellaneous

size is not localized in VisualizeUNET2D.

AddLossLyaer is misspelt in the doc guide page.

UNET symbol link doesn't work in the docs. Was this renamed to MakeUNET?

Cosmetic

Make the version shown in PacletInfo match the actual version. It's show in the doc browser.

Compatibility

Indicate in the README which Mathematica version is required and try to test with that version. The IDEA WL plugin is capable of highlighting symbols not present in the WL version you set. It's useful for detecting certain compatibility problems early. http://wlplugin.halirutan.de

Congratulations and many thanks for all your efforts, suggestions. Especially, I do really like the idea to illustrate and animate the training process.

For some applications, it might be interesting to use the segmented regions as boundaries for a partial differential equation system (e.g. to descrive a diffusion process or a wave or so)...

Frankly speaking, I have never seen these interesting loss layers, like SoftDiceLossLayer, BrierLossLayer.

Time to get closer to these network architectures! ;-)

Hope this helps

We have one input channel Nchan = 1

Step 1: split the lables into classes, for this exmaple Nclass = 4 (background, sphere, rectangle and overlap), so the network looks for 4 output lables.

Step 2: The first encoding layer split our input channel into 32 channels 1->32

Step 3: by the time we arrive at the deepest level our channels are downsampled but we have a lot of them

Step 4: After decoding we go back to 32 channels again. Hopefully by now each channel contains unique information about the image.

Step 5: We are looking for 4 labels so the 32 channels are mapped to 4 channels

Step 6: The 4 channels are converted to probability maps.

Step 7: The probability map become our 4 labels. In this case the network fail to correctly segment our example.

Our background and overlap are segmented whit a very high probability because they have a very distinct contrast which is easy to detect. However our circle and rectangle have the same contrast and have to be labeled based on their shape and not contrast. This is much more difficult and as such mistakes are made.

No there is no reason why the max size cannot be greater that 256, as long as the inputs size can be divided by 2 four times.

So any dimension that can be generated by (dim)2^4 should be fine. But indeed you will need more memory on your graphics card and training will take longer.

In TrainUNET the line that check dimensions I actually already increased for my own working version.

In this line the value max can be whatever you want, it was originally set to 20 but can be larger. 30 would do the trick for you.

(*check if data dimensions are valid for net*)
    If[(!AllTrue[MemberQ[Range[max]2^4,#]&/@datDim,TrueQ])&&(MemberQ[{2,3},netDim]),

The TrainUNET you don't have to use, it just does some extra stuff I found useful back when I was using it.

I don't know the optimal settings for the hyper parameters, the values that are in the UNET are ones that worked well for my problems so they might need tweaking.

Hi,

i wasnt sure what the current latest release contained. I just uploaded a new release 1.3 which contains a *.paclet file. download this file and use PacletInstall["fileDir\\UNET-1.3.0.paclet"] which will install the paclet. You can then load the toolbox with <<UNET`.

Some examples can be found in the UNET.nb file in the zip files also in the release.