Merge pull request #176 from dsyme/echk

dsyme · web-flow · commit 68ac7e20150c · 2020-11-10T17:53:47.000Z
avoid unnecessary p/invoke calls
diff --git a/src/Native/LibTorchSharp/Utils.cpp b/src/Native/LibTorchSharp/Utils.cpp
@@ -21,10 +21,3 @@ const char * make_sharable_string(const std::string str)
     return result;
 }
 
-Tensor ResultTensor(const at::Tensor& res)
-{
-    if (res.defined())
-        return new torch::Tensor(res);
-    else
-        return NULL;
-}
diff --git a/src/Native/LibTorchSharp/Utils.h b/src/Native/LibTorchSharp/Utils.h
@@ -41,7 +41,13 @@ typedef std::shared_ptr<torch::optim::Optimizer> * Optimizer;
 #define CATCH_RETURN_Tensor(stmt) CATCH_RETURN_RES(Tensor, NULL, stmt)
 
 // Return undefined tensors as NULL to C#
-Tensor ResultTensor(const at::Tensor & res);
+inline Tensor ResultTensor(const at::Tensor & res)
+{
+    if (res.defined())
+        return new torch::Tensor(res);
+    else
+        return NULL;
+}
 
 #define CATCH_TENSOR(expr) \
     at::Tensor res = at::Tensor(); \
diff --git a/src/TorchSharp/NN/AdaptiveAvgPool2D.cs b/src/TorchSharp/NN/AdaptiveAvgPool2D.cs
@@ -20,7 +20,7 @@ internal AdaptiveAvgPool2D (IntPtr handle, IntPtr boxedHandle) : base (handle, b
         public TorchTensor Forward (TorchTensor tensor)
         {
             var res = THSNN_AdaptiveAvgPool2d_forward (handle.DangerousGetHandle (), tensor.Handle);
-            Torch.CheckForErrors ();
+            if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new TorchTensor (res);
         }
     }
@@ -34,7 +34,7 @@ static public AdaptiveAvgPool2D AdaptiveAvgPool2D (long[] kernelSize)
             unsafe {
                 fixed (long* pkernelSize = kernelSize) {
                     var handle = THSNN_AdaptiveAvgPool2d_ctor ((IntPtr)pkernelSize, kernelSize.Length, out var boxedHandle);
-                    Torch.CheckForErrors ();
+                    if (handle == IntPtr.Zero) { Torch.CheckForErrors(); }
                     return new AdaptiveAvgPool2D (handle, boxedHandle);
                 }
             }
diff --git a/src/TorchSharp/NN/AvgPool2D.cs b/src/TorchSharp/NN/AvgPool2D.cs
@@ -20,7 +20,7 @@ internal AvgPool2D (IntPtr handle, IntPtr boxedHandle) : base (handle, boxedHand
         public TorchTensor Forward (TorchTensor tensor)
         {
             var res = THSNN_AvgPool2d_forward (handle.DangerousGetHandle (), tensor.Handle);
-            Torch.CheckForErrors ();
+            if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new TorchTensor (res);
         }
     }
@@ -34,7 +34,7 @@ static public AvgPool2D AvgPool2D (long[] kernelSize, long[] strides = null)
             unsafe {
                 fixed (long* pkernelSize = kernelSize, pstrides = strides) {
                     var handle = THSNN_AvgPool2d_ctor ((IntPtr)pkernelSize, kernelSize.Length, (IntPtr)pstrides, (strides == null ? 0 : strides.Length), out var boxedHandle);
-                    Torch.CheckForErrors ();
+                    if (handle == IntPtr.Zero) { Torch.CheckForErrors(); }
                     return new AvgPool2D (handle, boxedHandle);
                 }
             }
diff --git a/src/TorchSharp/NN/Conv2D.cs b/src/TorchSharp/NN/Conv2D.cs
@@ -15,7 +15,7 @@ internal Conv2D (IntPtr handle, IntPtr boxedHandle) : base (handle, boxedHandle)
         public TorchTensor Forward (TorchTensor tensor)
         {
             var res = THSNN_Conv2d_forward (handle, tensor.Handle);
-            Torch.CheckForErrors ();
+            if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new TorchTensor (res);
         }
     }
@@ -27,7 +27,7 @@ public static partial class Modules
         static public Conv2D Conv2D (long inputChannel, long outputChannel, long kernelSize, long stride = 1, long padding = 0)
         {
             var res = THSNN_Conv2d_ctor (inputChannel, outputChannel, kernelSize, stride, padding, out var boxedHandle);
-            Torch.CheckForErrors ();
+            if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new Conv2D (res, boxedHandle);
         }
     }
diff --git a/src/TorchSharp/NN/Dropout.cs b/src/TorchSharp/NN/Dropout.cs
@@ -18,7 +18,7 @@ internal Dropout (IntPtr handle, IntPtr boxedHandle) : base (handle, boxedHandle
         public TorchTensor Forward (TorchTensor tensor)
         {
             var res = THSNN_Dropout_forward (handle, tensor.Handle);
-            Torch.CheckForErrors ();
+            if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new TorchTensor (res);
         }
     }
@@ -30,7 +30,7 @@ public static partial class Modules
         static public Dropout Dropout (double probability = 0.5)
         {
             var handle = THSNN_Dropout_ctor (probability, out var boxedHandle);
-            Torch.CheckForErrors ();
+            if (handle == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new Dropout (handle, boxedHandle);
         }
     }
diff --git a/src/TorchSharp/NN/FeatureDropout.cs b/src/TorchSharp/NN/FeatureDropout.cs
@@ -20,7 +20,7 @@ internal FeatureAlphaDropout (IntPtr handle, IntPtr boxedHandle) : base (handle,
         public TorchTensor Forward (TorchTensor tensor)
         {
             var res = THSNN_FeatureAlphaDropout_forward (handle, tensor.Handle);
-            Torch.CheckForErrors ();
+            if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new TorchTensor (res);
         }
     }
@@ -32,7 +32,7 @@ public static partial class Modules
         static public FeatureAlphaDropout FeatureAlphaDropout (double probability = 0.5)
         {
             var handle = THSNN_FeatureAlphaDropout_ctor (probability, out var boxedHandle);
-            Torch.CheckForErrors ();
+            if (handle == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new FeatureAlphaDropout (handle, boxedHandle);
         }
     }
diff --git a/src/TorchSharp/NN/Linear.cs b/src/TorchSharp/NN/Linear.cs
@@ -15,7 +15,6 @@ internal Linear (IntPtr handle, IntPtr boxedHandle) : base (handle, boxedHandle)
         public new static Linear Load (String modelPath)
         {
             var res = Module.Load (modelPath);
-            Torch.CheckForErrors ();
             return new Linear (res.handle.DangerousGetHandle(), IntPtr.Zero);
         }
 
@@ -25,7 +24,7 @@ internal Linear (IntPtr handle, IntPtr boxedHandle) : base (handle, boxedHandle)
         public TorchTensor Forward (TorchTensor tensor)
         {
             var res = THSNN_Linear_forward (handle, tensor.Handle);
-            Torch.CheckForErrors ();
+            if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new TorchTensor (res);
         }
         [DllImport ("LibTorchSharp")]
@@ -36,7 +35,7 @@ public TorchTensor Forward (TorchTensor tensor)
         public TorchTensor? Bias {
             get {
                 var res = THSNN_Linear_bias (handle);
-                Torch.CheckForErrors ();
+                if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
                 return ((res == IntPtr.Zero) ? null : new TorchTensor (res));
             }
             set {
@@ -52,7 +51,7 @@ public TorchTensor? Bias {
         public TorchTensor Weight {
             get {
                 var res = THSNN_Linear_weight (handle);
-                Torch.CheckForErrors ();
+                if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
                 return new TorchTensor (res);
             }
             set {
@@ -69,7 +68,7 @@ public static partial class Modules
         static public Linear Linear (long inputSize, long outputSize, bool hasBias = true)
         {
             var res = THSNN_Linear_ctor (inputSize, outputSize, hasBias, out var boxedHandle);
-            Torch.CheckForErrors ();
+            if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new Linear (res, boxedHandle);
         }
     }
diff --git a/src/TorchSharp/NN/LogSoftMax.cs b/src/TorchSharp/NN/LogSoftMax.cs
@@ -20,7 +20,7 @@ internal LogSoftMax (IntPtr handle, IntPtr boxedHandle) : base (handle, boxedHan
         public TorchTensor Forward (TorchTensor tensor)
         {
             var res = THSNN_LogSoftMax_forward (handle, tensor.Handle);
-            Torch.CheckForErrors ();
+            if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new TorchTensor (res);
         }
     }
@@ -32,7 +32,7 @@ public static partial class Modules
         static public LogSoftMax LogSoftMax (long dimension)
         {
             var handle = THSNN_LogSoftMax_ctor (dimension, out var boxedHandle);
-            Torch.CheckForErrors ();
+            if (handle == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new LogSoftMax (handle, boxedHandle);
         }
     }
diff --git a/src/TorchSharp/NN/Losses.cs b/src/TorchSharp/NN/Losses.cs
@@ -22,7 +22,7 @@ public static Loss BCE (TorchTensor? weigths = null, Reduction reduction = Reduc
         {
             return (TorchTensor src, TorchTensor target) => {
                 var res = THSNN_binary_cross_entropy (src.Handle, target.Handle, weigths?.Handle ?? IntPtr.Zero, (long)reduction);
-                Torch.CheckForErrors ();
+                if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
                 return new TorchTensor (res);
             };
         }
@@ -34,7 +34,7 @@ public static Loss MSE (Reduction reduction = Reduction.Mean)
         {
             return (TorchTensor src, TorchTensor target) => {
                     var res = THSNN_mse_loss (src.Handle, target.Handle, (long)reduction);
-                    Torch.CheckForErrors ();
+                    if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
                     return new TorchTensor (res);
                 };
         }
@@ -46,7 +46,7 @@ public static Loss NLL (TorchTensor? weigths = null, Reduction reduction = Reduc
         {
             return (TorchTensor src, TorchTensor target) => {
                 var res = THSNN_nll_loss (src.Handle, target.Handle, weigths?.Handle ?? IntPtr.Zero, (long)reduction);
-                Torch.CheckForErrors ();
+                if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
                 return new TorchTensor (res);
             };
         }
@@ -58,7 +58,7 @@ public static Loss PoissonNLL (bool logInput = true, bool full = false, float ep
         {
             return (TorchTensor src, TorchTensor target) => {
                 var res = THSNN_poisson_loss (src.Handle, target.Handle, logInput, full, eps, (long)reduction);
-                Torch.CheckForErrors ();
+                if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
                 return new TorchTensor (res);
             };
         }
diff --git a/src/TorchSharp/NN/MaxPool2D.cs b/src/TorchSharp/NN/MaxPool2D.cs
@@ -20,7 +20,7 @@ internal MaxPool2D (IntPtr handle, IntPtr boxedHandle) : base (handle, boxedHand
         public TorchTensor Forward (TorchTensor tensor)
         {
             var res = THSNN_MaxPool2d_forward (handle, tensor.Handle);
-            Torch.CheckForErrors ();
+            if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new TorchTensor (res);
         }
     }
@@ -34,7 +34,7 @@ static public MaxPool2D MaxPool2D (long[] kernelSize, long[] strides = null)
             unsafe {
                 fixed (long* pkernelSize = kernelSize, pstrides = strides) {
                     var handle = THSNN_MaxPool2d_ctor ((IntPtr)pkernelSize, kernelSize.Length, (IntPtr)pstrides, (strides == null ? 0 : strides.Length), out var boxedHandle);
-                    Torch.CheckForErrors ();
+                    if (handle == IntPtr.Zero) { Torch.CheckForErrors(); }
                     return new MaxPool2D (handle, boxedHandle);
                 }
             }
diff --git a/src/TorchSharp/NN/Module.cs b/src/TorchSharp/NN/Module.cs
@@ -97,7 +97,7 @@ protected void Dispose (bool disposing)
         public static Module Load(String location)
         {
             var handle = THSNN_Module_load (location);
-            Torch.CheckForErrors ();
+            if (handle == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new Module (handle, IntPtr.Zero);
         }
 
diff --git a/src/TorchSharp/NN/Optimizer.cs b/src/TorchSharp/NN/Optimizer.cs
@@ -87,7 +87,7 @@ public static Optimizer Adam (IEnumerable<TorchTensor> parameters, double learni
             IntPtr paramsRef = parray.CreateArray (parameters.Select (p => p.Handle).ToArray ());
 
             var res = THSNN_Adam_ctor (paramsRef, parray.Array.Length, learningRate);
-            Torch.CheckForErrors ();
+            if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new Optimizer (res);
         }
 
@@ -100,7 +100,7 @@ public static Optimizer SGD (IEnumerable<TorchTensor> parameters, double learnin
             IntPtr paramsRef = parray.CreateArray (parameters.Select (p => p.Handle).ToArray ());
 
             var res = THSNN_SGD_ctor (paramsRef, parray.Array.Length, learningRate, momentum);
-            Torch.CheckForErrors ();
+            if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new Optimizer (res);
         }
 
diff --git a/src/TorchSharp/NN/ReLu.cs b/src/TorchSharp/NN/ReLu.cs
@@ -18,7 +18,7 @@ internal ReLU (IntPtr handle, IntPtr boxedHandle) : base (handle, boxedHandle) {
         public TorchTensor Forward (TorchTensor tensor)
         {
             var res = THSNN_ReLU_forward (handle, tensor.Handle);
-            Torch.CheckForErrors ();
+            if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new TorchTensor (res);
         }
 
@@ -36,7 +36,7 @@ public static partial class Modules
         static public ReLU Relu (bool inPlace = false)
         {
             var handle = THSNN_ReLU_ctor (inPlace, out var boxedHandle);
-            Torch.CheckForErrors ();
+            if (handle == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new ReLU (handle, boxedHandle);
         }
     }
diff --git a/src/TorchSharp/NN/Sequential.cs b/src/TorchSharp/NN/Sequential.cs
@@ -38,7 +38,7 @@ internal Sequential (IntPtr handle) : base (handle, IntPtr.Zero)
         public TorchTensor Forward (TorchTensor tensor)
         {
             var res = THSNN_Sequential_forward (handle, tensor.Handle);
-            Torch.CheckForErrors ();
+            if (res == IntPtr.Zero) { Torch.CheckForErrors(); }
             return new TorchTensor (res);
         }
 
@@ -52,7 +52,7 @@ public static partial class Modules
         static public Sequential Sequential (params (string name, Module submodule)[] modules)
         {
             var handle = THSNN_Sequential_ctor ();
-            Torch.CheckForErrors ();
+            if (handle == IntPtr.Zero) { Torch.CheckForErrors(); }
             var res = new Sequential (handle);
             foreach (var module in modules)
                 res.Add(module.name, module.submodule);
diff --git a/src/TorchSharp/Tensor/TorchTensor.cs b/src/TorchSharp/Tensor/TorchTensor.cs
diff --git a/src/TorchSharp/Tensor/TorchTensorTyped.generated.cs b/src/TorchSharp/Tensor/TorchTensorTyped.generated.cs
diff --git a/src/TorchSharp/Tensor/TorchTensorTyped.tt b/src/TorchSharp/Tensor/TorchTensorTyped.tt

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ internal AdaptiveAvgPool2D (IntPtr handle, IntPtr boxedHandle) : base (handle, b`
`20`	`20`	`public TorchTensor Forward (TorchTensor tensor)`
`21`	`21`	`{`
`22`	`22`	`var res = THSNN_AdaptiveAvgPool2d_forward (handle.DangerousGetHandle (), tensor.Handle);`
`23`		`- Torch.CheckForErrors ();`
	`23`	`+ if (res == IntPtr.Zero) { Torch.CheckForErrors(); }`
`24`	`24`	`return new TorchTensor (res);`
`25`	`25`	`}`
`26`	`26`	`}`
`@@ -34,7 +34,7 @@ static public AdaptiveAvgPool2D AdaptiveAvgPool2D (long[] kernelSize)`
`34`	`34`	`unsafe {`
`35`	`35`	`fixed (long* pkernelSize = kernelSize) {`
`36`	`36`	`var handle = THSNN_AdaptiveAvgPool2d_ctor ((IntPtr)pkernelSize, kernelSize.Length, out var boxedHandle);`
`37`		`- Torch.CheckForErrors ();`
	`37`	`+ if (handle == IntPtr.Zero) { Torch.CheckForErrors(); }`
`38`	`38`	`return new AdaptiveAvgPool2D (handle, boxedHandle);`
`39`	`39`	`}`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ internal AvgPool2D (IntPtr handle, IntPtr boxedHandle) : base (handle, boxedHand`
`20`	`20`	`public TorchTensor Forward (TorchTensor tensor)`
`21`	`21`	`{`
`22`	`22`	`var res = THSNN_AvgPool2d_forward (handle.DangerousGetHandle (), tensor.Handle);`
`23`		`- Torch.CheckForErrors ();`
	`23`	`+ if (res == IntPtr.Zero) { Torch.CheckForErrors(); }`
`24`	`24`	`return new TorchTensor (res);`
`25`	`25`	`}`
`26`	`26`	`}`
`@@ -34,7 +34,7 @@ static public AvgPool2D AvgPool2D (long[] kernelSize, long[] strides = null)`
`34`	`34`	`unsafe {`
`35`	`35`	`fixed (long* pkernelSize = kernelSize, pstrides = strides) {`
`36`	`36`	`var handle = THSNN_AvgPool2d_ctor ((IntPtr)pkernelSize, kernelSize.Length, (IntPtr)pstrides, (strides == null ? 0 : strides.Length), out var boxedHandle);`
`37`		`- Torch.CheckForErrors ();`
	`37`	`+ if (handle == IntPtr.Zero) { Torch.CheckForErrors(); }`
`38`	`38`	`return new AvgPool2D (handle, boxedHandle);`
`39`	`39`	`}`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ internal Conv2D (IntPtr handle, IntPtr boxedHandle) : base (handle, boxedHandle)`
`15`	`15`	`public TorchTensor Forward (TorchTensor tensor)`
`16`	`16`	`{`
`17`	`17`	`var res = THSNN_Conv2d_forward (handle, tensor.Handle);`
`18`		`- Torch.CheckForErrors ();`
	`18`	`+ if (res == IntPtr.Zero) { Torch.CheckForErrors(); }`
`19`	`19`	`return new TorchTensor (res);`
`20`	`20`	`}`
`21`	`21`	`}`
`@@ -27,7 +27,7 @@ public static partial class Modules`
`27`	`27`	`static public Conv2D Conv2D (long inputChannel, long outputChannel, long kernelSize, long stride = 1, long padding = 0)`
`28`	`28`	`{`
`29`	`29`	`var res = THSNN_Conv2d_ctor (inputChannel, outputChannel, kernelSize, stride, padding, out var boxedHandle);`
`30`		`- Torch.CheckForErrors ();`
	`30`	`+ if (res == IntPtr.Zero) { Torch.CheckForErrors(); }`
`31`	`31`	`return new Conv2D (res, boxedHandle);`
`32`	`32`	`}`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ internal Dropout (IntPtr handle, IntPtr boxedHandle) : base (handle, boxedHandle`
`18`	`18`	`public TorchTensor Forward (TorchTensor tensor)`
`19`	`19`	`{`
`20`	`20`	`var res = THSNN_Dropout_forward (handle, tensor.Handle);`
`21`		`- Torch.CheckForErrors ();`
	`21`	`+ if (res == IntPtr.Zero) { Torch.CheckForErrors(); }`
`22`	`22`	`return new TorchTensor (res);`
`23`	`23`	`}`
`24`	`24`	`}`
`@@ -30,7 +30,7 @@ public static partial class Modules`
`30`	`30`	`static public Dropout Dropout (double probability = 0.5)`
`31`	`31`	`{`
`32`	`32`	`var handle = THSNN_Dropout_ctor (probability, out var boxedHandle);`
`33`		`- Torch.CheckForErrors ();`
	`33`	`+ if (handle == IntPtr.Zero) { Torch.CheckForErrors(); }`
`34`	`34`	`return new Dropout (handle, boxedHandle);`
`35`	`35`	`}`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ internal FeatureAlphaDropout (IntPtr handle, IntPtr boxedHandle) : base (handle,`
`20`	`20`	`public TorchTensor Forward (TorchTensor tensor)`
`21`	`21`	`{`
`22`	`22`	`var res = THSNN_FeatureAlphaDropout_forward (handle, tensor.Handle);`
`23`		`- Torch.CheckForErrors ();`
	`23`	`+ if (res == IntPtr.Zero) { Torch.CheckForErrors(); }`
`24`	`24`	`return new TorchTensor (res);`
`25`	`25`	`}`
`26`	`26`	`}`
`@@ -32,7 +32,7 @@ public static partial class Modules`
`32`	`32`	`static public FeatureAlphaDropout FeatureAlphaDropout (double probability = 0.5)`
`33`	`33`	`{`
`34`	`34`	`var handle = THSNN_FeatureAlphaDropout_ctor (probability, out var boxedHandle);`
`35`		`- Torch.CheckForErrors ();`
	`35`	`+ if (handle == IntPtr.Zero) { Torch.CheckForErrors(); }`
`36`	`36`	`return new FeatureAlphaDropout (handle, boxedHandle);`
`37`	`37`	`}`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,6 @@ internal Linear (IntPtr handle, IntPtr boxedHandle) : base (handle, boxedHandle)`
`15`	`15`	`public new static Linear Load (String modelPath)`
`16`	`16`	`{`
`17`	`17`	`var res = Module.Load (modelPath);`
`18`		`- Torch.CheckForErrors ();`
`19`	`18`	`return new Linear (res.handle.DangerousGetHandle(), IntPtr.Zero);`
`20`	`19`	`}`
`21`	`20`
`@@ -25,7 +24,7 @@ internal Linear (IntPtr handle, IntPtr boxedHandle) : base (handle, boxedHandle)`
`25`	`24`	`public TorchTensor Forward (TorchTensor tensor)`
`26`	`25`	`{`
`27`	`26`	`var res = THSNN_Linear_forward (handle, tensor.Handle);`
`28`		`- Torch.CheckForErrors ();`
	`27`	`+ if (res == IntPtr.Zero) { Torch.CheckForErrors(); }`
`29`	`28`	`return new TorchTensor (res);`
`30`	`29`	`}`
`31`	`30`	`[DllImport ("LibTorchSharp")]`
`@@ -36,7 +35,7 @@ public TorchTensor Forward (TorchTensor tensor)`
`36`	`35`	`public TorchTensor? Bias {`
`37`	`36`	`get {`
`38`	`37`	`var res = THSNN_Linear_bias (handle);`
`39`		`- Torch.CheckForErrors ();`
	`38`	`+ if (res == IntPtr.Zero) { Torch.CheckForErrors(); }`
`40`	`39`	`return ((res == IntPtr.Zero) ? null : new TorchTensor (res));`
`41`	`40`	`}`
`42`	`41`	`set {`
`@@ -52,7 +51,7 @@ public TorchTensor? Bias {`
`52`	`51`	`public TorchTensor Weight {`
`53`	`52`	`get {`
`54`	`53`	`var res = THSNN_Linear_weight (handle);`
`55`		`- Torch.CheckForErrors ();`
	`54`	`+ if (res == IntPtr.Zero) { Torch.CheckForErrors(); }`
`56`	`55`	`return new TorchTensor (res);`
`57`	`56`	`}`
`58`	`57`	`set {`
`@@ -69,7 +68,7 @@ public static partial class Modules`
`69`	`68`	`static public Linear Linear (long inputSize, long outputSize, bool hasBias = true)`
`70`	`69`	`{`
`71`	`70`	`var res = THSNN_Linear_ctor (inputSize, outputSize, hasBias, out var boxedHandle);`
`72`		`- Torch.CheckForErrors ();`
	`71`	`+ if (res == IntPtr.Zero) { Torch.CheckForErrors(); }`
`73`	`72`	`return new Linear (res, boxedHandle);`
`74`	`73`	`}`
`75`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ internal LogSoftMax (IntPtr handle, IntPtr boxedHandle) : base (handle, boxedHan`
`20`	`20`	`public TorchTensor Forward (TorchTensor tensor)`
`21`	`21`	`{`
`22`	`22`	`var res = THSNN_LogSoftMax_forward (handle, tensor.Handle);`
`23`		`- Torch.CheckForErrors ();`
	`23`	`+ if (res == IntPtr.Zero) { Torch.CheckForErrors(); }`
`24`	`24`	`return new TorchTensor (res);`
`25`	`25`	`}`
`26`	`26`	`}`
`@@ -32,7 +32,7 @@ public static partial class Modules`
`32`	`32`	`static public LogSoftMax LogSoftMax (long dimension)`
`33`	`33`	`{`
`34`	`34`	`var handle = THSNN_LogSoftMax_ctor (dimension, out var boxedHandle);`
`35`		`- Torch.CheckForErrors ();`
	`35`	`+ if (handle == IntPtr.Zero) { Torch.CheckForErrors(); }`
`36`	`36`	`return new LogSoftMax (handle, boxedHandle);`
`37`	`37`	`}`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public static Loss BCE (TorchTensor? weigths = null, Reduction reduction = Reduc`
`22`	`22`	`{`
`23`	`23`	`return (TorchTensor src, TorchTensor target) => {`
`24`	`24`	`var res = THSNN_binary_cross_entropy (src.Handle, target.Handle, weigths?.Handle ?? IntPtr.Zero, (long)reduction);`
`25`		`- Torch.CheckForErrors ();`
	`25`	`+ if (res == IntPtr.Zero) { Torch.CheckForErrors(); }`
`26`	`26`	`return new TorchTensor (res);`
`27`	`27`	`};`
`28`	`28`	`}`
`@@ -34,7 +34,7 @@ public static Loss MSE (Reduction reduction = Reduction.Mean)`
`34`	`34`	`{`
`35`	`35`	`return (TorchTensor src, TorchTensor target) => {`
`36`	`36`	`var res = THSNN_mse_loss (src.Handle, target.Handle, (long)reduction);`
`37`		`- Torch.CheckForErrors ();`
	`37`	`+ if (res == IntPtr.Zero) { Torch.CheckForErrors(); }`
`38`	`38`	`return new TorchTensor (res);`
`39`	`39`	`};`
`40`	`40`	`}`
`@@ -46,7 +46,7 @@ public static Loss NLL (TorchTensor? weigths = null, Reduction reduction = Reduc`
`46`	`46`	`{`
`47`	`47`	`return (TorchTensor src, TorchTensor target) => {`
`48`	`48`	`var res = THSNN_nll_loss (src.Handle, target.Handle, weigths?.Handle ?? IntPtr.Zero, (long)reduction);`
`49`		`- Torch.CheckForErrors ();`
	`49`	`+ if (res == IntPtr.Zero) { Torch.CheckForErrors(); }`
`50`	`50`	`return new TorchTensor (res);`
`51`	`51`	`};`
`52`	`52`	`}`
`@@ -58,7 +58,7 @@ public static Loss PoissonNLL (bool logInput = true, bool full = false, float ep`
`58`	`58`	`{`
`59`	`59`	`return (TorchTensor src, TorchTensor target) => {`
`60`	`60`	`var res = THSNN_poisson_loss (src.Handle, target.Handle, logInput, full, eps, (long)reduction);`
`61`		`- Torch.CheckForErrors ();`
	`61`	`+ if (res == IntPtr.Zero) { Torch.CheckForErrors(); }`
`62`	`62`	`return new TorchTensor (res);`
`63`	`63`	`};`
`64`	`64`	`}`