examples/charRNN Crashes When Run about gorgonia HOT 5 OPEN

g := gorgonia.NewGraph()

x := gorgonia.NewVector(g, tensor.Float64, gorgonia.WithShape(seqLen, inputSize), gorgonia.WithName("x"))
y := gorgonia.NewVector(g, tensor.Float64, gorgonia.WithShape(seqLen, outputSize), gorgonia.WithName("y"))
h := gorgonia.NewVector(g, tensor.Float64, gorgonia.WithShape(seqLen, hiddenSize), gorgonia.WithName("h"))

// the input-to-hidden weights
Wxh := gorgonia.NewMatrix(g, tensor.Float64, gorgonia.WithShape(inputSize, hiddenSize), gorgonia.WithName("Wxh"))
// the hidden-to-hidden weights
Whh := gorgonia.NewMatrix(g, tensor.Float64, gorgonia.WithShape(hiddenSize, hiddenSize), gorgonia.WithName("Whh"))
// the hidden-to-output weights
Why := gorgonia.NewMatrix(g, tensor.Float64, gorgonia.WithShape(hiddenSize, outputSize), gorgonia.WithName("Why"))
// the hidden biases
bh := gorgonia.NewVector(g, tensor.Float64, gorgonia.WithShape(hiddenSize), gorgonia.WithName("bh"))
// the output biases
by := gorgonia.NewVector(g, tensor.Float64, gorgonia.WithShape(outputSize), gorgonia.WithName("by"))

// Define the forward pass
var hPrev *gorgonia.Node
for i := 0; i < seqLen; i++ {
    // Compute the input-to-hidden activations
    hI := gorgonia.Must(gorgonia.Mul(x.Slice(i, i+1), Wxh))
    
    // Compute the hidden-to-hidden activations
    hH := gorgonia.Must(gorgonia.Mul(hPrev, Whh))
    
    // Compute the total hidden activations
    hTotal := gorgonia.Must(gorgonia.Add(hI, hH, bh))
    
    // Compute the hidden activations
    h[i], err = gorgonia.Tanh(hTotal)
    if err != nil {
        log.Fatal(err)
    }
    
    // Compute the output activations
    oI := gorgonia.Must(gorgonia.Mul(h[i], Why))
    y[i], err = gorgonia.Sigmoid(gorgonia.Must(gorgonia.Add(oI, by)))
    if err != nil {
        log.Fatal(err)
    }
    
    hPrev = h[i]
}

loss := gorgonia.Must(gorgonia.Mean(gorgonia.Must(gorgonia.Square(gorgonia.Must(gorgonia.Sub(y, yTrue))))))

grads, err := gorgonia.Grad(loss, Wxh, Whh, Why, bh, by)
if err != nil {
    log.Fatal(err)
}

solver := gorgonia.NewRMSPropSolver(gorgonia.WithLearnRate(0.001))

 vm=gorgonia.NewTapeMachine(g)
for i := 0; i < numEpochs; i++ {
    // Perform the forward pass and compute the loss and gradients
    gorgonia.Let(x, ...)
   gorgonia.Let(y, ...)
   vm.Run()
  // Back prop
   solver.Step(gorgonia.NodesToValueGrads( []*gorgonia.Node{Wxh, Whh, Why, bh, by})
  vm.Reset()
}

func sample(val Value) int {
	var t tensor.Tensor
	var ok bool
	if t, ok = val.(tensor.Tensor); !ok {
		panic("Expects a tensor")
	}

	// It is logprob, convert it back to prob
	t2, err := tensor.Exp(t, tensor.AsSameType())
	if err != nil {
		panic("Error converting to prob")
	}

	return tensor.SampleIndex(t2)
}