It would be nice to see this work in v13. Here's an attempt to update the nonexistent functions from v11, check it out:

https://www.wolframcloud.com/obj/msollami/Published/colorization-2016.nb

There are only a few small changes that need to be made, for example:

(*upSampl = UpsampleLayer[2];*)
upSampl = ResizeLayer[{Scaled @ 2, Scaled @ 2}];
(* sl = SplitLayer[False]; *)
sl = TransposeLayer[3->1]; 
(* bl = BroadcastPlusLayer[]; *)
bl = CatenateLayer[InputPorts -> {"LHS", "RHS"}];

But the final NetGraph doesn't like them:

This post is the only example of colorization that contains training/loss details, which are almost always missing from construction notebooks in WNNR. Let's help make this work again in v13...

Are there any Wolfram Function Repository entries related to these kind of colorizations?

This one, no (for various reasons). A better one will be published very soon.

This is very interesting work! I have the NetChain from the discussion above and it looks fine and seems to work with a small training set. It is big training task to use the "Places" dataset and not really practical for the resources I have.

So my question - and this is really a question to Sebastian who mentioned it earlier in the discussion - could the trained network be made available?

This is a good examples article for people who are interested in this project: http://www.thisisinsider.com/digitally-recolored-photos-2016-6

Global Variables

(* Loss function parameter and number of classes of the images *)
$\[Alpha] = 1/300;
$numClasses = 4314;

Net Layers

conv[out_Integer, k_Integer, str_Integer, p_Integer] := ConvolutionLayer[out, k, "Stride" -> str, "PaddingSize" -> p]; (* Convolution layer *)
fc[n_Integer] := DotPlusLayer[n]; (* Fully connected layer *)
relu = ElementwiseLayer[Ramp]; (* Ramp activation function *)
\[Sigma] = ElementwiseLayer[LogisticSigmoid];(* Sigmoid activation function *)
\[Sigma]1 = ElementwiseLayer[LogisticSigmoid];
tl1 = ScalarTimesLayer[100];  (* This layer multiplies elementwise the input tensor by a scalar number *)
tl2 = ScalarTimesLayer[100];
timesLoss = ScalarTimesLayer[$\[Alpha]];
bn = BatchNormalizationLayer[]; (* Batch Normalizaion layer *)
upSampl = UpsampleLayer[2]; (* Upsampling using the nearest neighbor techique *)
sl = SplitLayer[False];  (* This layer splits the input tensor into its channels *)     
cl = CatenateLayer[]; (* This layer catenates the input tensors and outputs a new tensor *)

(* "Fusion" layer *)
rshL = ReshapeLayer[{256, 1, 1}]; (* This layer reinterprets the input to be an array of the specified dimensions *)
bl = BroadcastPlusLayer[]; (* This layer catenates a vector all along the corresponding dimension of a tensor *)

(* Loss functions *)
lossMS = MeanSquaredLossLayer[]; 
lossCE = CrossEntropyLossLayer["Index"]; 

Net Chains

(* Low-Level Features Network *)
lln = NetChain[{conv[64, 3, 2, 1], bn, relu, conv[128, 3, 1, 1], bn, relu, conv[128, 3, 2, 1], bn, relu, conv[256, 3, 1, 1], bn, relu, 
    conv[256, 3, 2, 1], bn, relu, conv[512, 3, 1, 1], bn, relu} ];
(* Mid-Level Features Network *)
mln = NetChain[{conv[512, 3, 1, 1], bn, relu, conv[256, 3, 1, 1], bn, relu}];
(* Colorization Network *)
coln = NetChain[{conv[256, 3, 1, 1], bn, relu, conv[128, 3, 1, 1], bn, relu, upSampl, conv[64, 3, 1, 1], bn, relu, conv[64, 3, 1, 1], 
    bn, relu, upSampl, conv[32, 3, 1, 1], bn, relu, conv[2, 3, 1, 1], \[Sigma], upSampl}];
(* Global Features Network *)
gln = NetChain[{conv[512, 3, 2, 1], bn, relu, conv[512, 3, 1, 1], bn, relu, conv[512, 3, 2, 1], bn, relu, conv[512, 3, 1, 1], bn, relu, 
    FlattenLayer[], fc[1024], bn, relu, fc[512], bn, relu}];
gln2 = NetChain[{fc[256], bn, relu}];
(* Classification Network *)
classn = NetChain[{fc[256], bn, relu, fc[$numClasses], bn, relu}];

Net Structure

classNet = NetGraph[
  <| "SplitL" -> sl, "LowLev" -> lln, "MidLev" -> mln, "GlobLev" -> gln, "GlobLev2" -> gln2, "ColNet" -> coln, "Sigmoid" -> \[Sigma]1, "TimesL1" -> tl1, "TimesL2" -> tl2, "CatL" -> cl, "LossMS" -> lossMS, "LossCE" -> lossCE, "Broadcast" -> bl, "ReshapeL" -> rshL, "ClassN" -> classn, "timesLoss" -> timesLoss |>,
  { NetPort["Image"] -> "SplitL",  "SplitL" -> {"LowLev", "TimesL1", "TimesL2"}, {"TimesL1", "TimesL2"} -> "CatL", "CatL" -> "Sigmoid", "LowLev" -> "MidLev", "LowLev" -> "GlobLev", "GlobLev" -> "GlobLev2", "GlobLev" -> "ClassN", "MidLev" -> NetPort["Broadcast", "LHS"], "GlobLev2" -> "ReshapeL", "ReshapeL" -> NetPort["Broadcast", "RHS"], "Broadcast" -> "ColNet",
    "ColNet" -> NetPort["LossMS", "Input"], "Sigmoid" -> NetPort["LossMS", "Target"],  "ClassN" -> NetPort["LossCE", "Input"], 
   NetPort["Class"] -> NetPort["LossCE", "Target"], "LossCE" -> "timesLoss" }, 
  "Image" -> NetEncoder[{"Image", {224, 224}, "ColorSpace" -> "LAB", "Parallelize" -> False}] ]

Training

tnet = NetTrain [
  classNet,
  <|"Image" -> $trainPathsFile, "Class" -> $trainClasses|>,
  ValidationSet -> <|"Image" -> $testPathsFile, "Class" -> $testClasses|>,
  TargetDevice -> {"GPU", 1},
  "Method" -> "ADAM"
  ]

Evaluation Net

evalNet = Take[tnet, {"LowLev", "ColNet"}]
evalNet = NetChain[{evalNet}, "Input"->NetEncoder["Image",{224,224},"ColorSpace"->"Grayscale"]];

Thank you!!!

This network will only be runnable in the released version of M11.

Also: we are continuing to train the model (requires at least 2-3 weeks of training on a Titan X GPU for optimal performance, the images above were produced by a 14 hour trained net). If there is interest, I can post the trained net in 2 weeks time.

We are also working on a model gallery for 11.1 where we will post trained models like this one.

Very impressive, thanks for sharing!