anchor.diff:      let dilation = defaultArg dilation 1
       let bias = defaultArg bias true
       let k = 1./ sqrt (float (inChannels*kernelSize))
  -    let w = Parameter <| -k + dsharp.rand([outChannels; inChannels; kernelSize]) * 2*k
  -    let b = Parameter <| if bias then -k + dsharp.rand(outChannels) * 2*k else dsharp.zero()
  +    let w = Parameter <| Init.init([|outChannels; inChannels; kernelSize|], k)
  +    let b = Parameter <| if bias then Init.init([|outChannels|], k) else dsharp.zero()
       do base.add(["weight", w; "bias", b])
       override c.forward(value) =
           let f = dsharp.conv1d(value, w.value, stride=stride, padding=padding, dilation=dilation)
  
positive.code:     member d.add(parameters:list<string*Parameter>) = for (n, p) in parameters do d.add(n, p)
      member d.add(parameters:ParameterDict) = for KeyValue(n, p) in parameters.values do d.add(n, p)
      member d.copy() = d.map(fun (t:Tensor) -> t)
      member d.map(f:string*Tensor->string*Tensor) =
          let ret = ParameterDict()
          for KeyValue(n, p) in d.values do ret.values.Add(let nn, pp = f(n,p.value) in nn, Parameter(pp))
          ret
      member d.map(f:Tensor->Tensor) = d.map(fun (n,t) -> n, f t)
      member d.set(parameters:ParameterDict) = d.iter(fun (n, p) -> p.value <- parameters.[n])
      member d.iter(f:string*Parameter->unit) = for KeyValue(n, p) in d.values do f(n,p)
  
negative.code:     member p.forwardDiff(derivative:Tensor) = p.value <- p.value.forwardDiff(derivative)
      member p.reverseDiff() = p.value <- p.value.reverseDiff()
      member p.noDiff() = p.value <- p.value.noDiff()
      override p.ToString() = sprintf "Parameter(shape: %A, value: %A)" p.value.shape p.value
  
  type ParameterDict() =
      member val values:Dictionary<string, Parameter> = Dictionary()
  