anchor.diff:      member val ParametersDict = ParameterDict()
   
       /// <summary>TBD</summary>
  -    member val SubModelsDict = Dictionary<string, Model>()
  +    member val SubModelsDict = Dictionary<string, BaseModel>()
   
       /// <summary>TBD</summary>
       member m.train() = 
           m.mode <- Mode.Train
  -        for model:Model in m.allModels do model.mode <- Mode.Train
  +        for model:BaseModel in m.allModels do model.mode <- Mode.Train
   
       /// <summary>TBD</summary>
       member m.eval() = 
           m.mode <- Mode.Eval
  -        for model:Model in m.allModels do model.mode <- Mode.Eval
  +        for model:BaseModel in m.allModels do model.mode <- Mode.Eval
   
       /// <summary>TBD</summary>
       member m.parametersDict
  
positive.code:     member m.nparameters = m.parametersDict.nelement
  
      /// <summary>TBD</summary>
      abstract member forward: Tensor -> Tensor
  
      /// <summary>TBD</summary>
      member m.forwardParameters (input:Tensor) (parameters:Tensor) =
          m.parameters <- parameters
          let f = m.forward(input) in m.noDiff(); f
  
      /// <summary>TBD</summary>
      member m.forwardCompose (f:Tensor->Tensor) (input:Tensor) (parameters:Tensor) =
          m.forwardParameters input parameters |> f
  
      /// <summary>TBD</summary>
      member m.forwardLoss (f:Tensor->Tensor->Tensor) (input:Tensor) (target:Tensor) (parameters:Tensor) =
          m.forwardCompose (f target) input parameters
  
      /// <summary>TBD</summary>
      static member create ps f =
          let model = { new Model() with override __.forward(x) = f x}
          model.add(ps)
          model
  
      /// <summary>TBD</summary>
      override m.ToString() =
  
negative.code:             match (box p) with
              | :? Parameter as p -> 
                  m.parametersDict.add(n, p)
              | :? BaseModel as mm ->
                  m.SubModelsDict.Add(n, mm)
                  m.parametersDict.add(mm.parametersDict.map(fun (nn, pp:Parameter) -> (n + "__" + nn, pp)))
              | :? (Parameter * string) as pn -> 
                  let (p,n) = pn
                  m.parametersDict.add(n, p)
              | :? (BaseModel * string) as mmn -> 
                  let (mm,n) = mmn
                  m.SubModelsDict.Add(n, mm)
                  m.parametersDict.add(mm.parametersDict.map(fun (nn, pp:Parameter) -> (n + "__" + nn, pp)))
              | t -> failwithf "Unsupported type %A. Expecting a Parameter or Model" (t.GetType())
  
      /// <summary>TBD</summary>
      member m.forwardDiff(derivatives:ParameterDict) = m.parametersDict.forwarddiff(derivatives)
  