Merge pull request #1319 from NiklasGustafsson/missing

Adding 'set/get_default_device()'

Author: NiklasGustafsson

RELEASENOTES.md

@@ -12,6 +12,7 @@ The constructor of dispose scopes is no longer `public`. Use `torch.NewDisposeSc
 
 __API Changes__:
 
+#1317 How to set default device type in torchsharp.<br/>
 #1314 Grant read-only access to DataLoader attributes<br/>
 #1313 Add 'non_blocking' argument to tensor and module 'to()' signatures.<br/>
 #1291 `Tensor.grad()` and `Tensor.set_grad()` have been replaced by a new property `Tensor.grad`.<br/>

src/TorchSharp/NN/Module.cs

@@ -1063,8 +1063,10 @@ protected static (Device device, ScalarType dtype) GetDefaultDeviceAndType(Devic
                     if (!dtype.HasValue)
                         dtype = get_default_dtype();
 
-                    if (device == null)
-                        device = torch.CPU;
+                    if (device is null)
+                    {
+                        device = get_default_device();
+                    }
 
                     return (device, dtype.Value);
                 }

src/TorchSharp/Tensor/Factories/Tensor.Factories.cs

@@ -579,6 +579,7 @@ private static void ValidateIntegerRange(long value, ScalarType dtype, string ar
 
         private static ConcurrentDictionary<TorchSharp.PInvoke.GCHandleDeleter, TorchSharp.PInvoke.GCHandleDeleter> deleters;
         private static ScalarType default_dtype = ScalarType.Float32;
+        private static Device default_device = new Device(DeviceType.CPU, -1);
 
         static torch()
         {

src/TorchSharp/Tensor/Tensor.cs

@@ -880,7 +880,7 @@ public Tensor to(DeviceType deviceType, int deviceIndex = -1, bool copy = false,
             /// <param name="non_blocking">Try to convert asynchronously with respect to the host if possible, e.g., converting a CPU Tensor with pinned memory to a CUDA Tensor.</param>
             public Tensor to(ScalarType type, torch.Device device, bool copy = false, bool disposeAfter = false, bool non_blocking = false)
             {
-                torch.InitializeDevice(device);
+                device = torch.InitializeDevice(device);
                 var res = NativeMethods.THSTensor_to_type_and_device(Handle, (sbyte)type, (int)device.type, device.index, copy, non_blocking);
                 if (res == IntPtr.Zero)
                     CheckForErrors();

src/TorchSharp/Tensor/torch.Tensors.cs

@@ -61,9 +61,23 @@ public static void set_default_dtype(ScalarType dtype)
         /// <returns></returns>
         [Pure]public static ScalarType get_default_dtype() => default_dtype;
 
+        [Pure]public static Device get_default_device() => default_device;
+
         // https://pytorch.org/docs/stable/generated/torch.set_default_tensor_type
         public static void set_default_tensor_type(Tensor t) => set_default_dtype(t.dtype);
 
+        public static void set_default_device(Device device) 
+        {
+            if (device == null) 
+                throw new ArgumentNullException(nameof(device));
+            default_device = device;
+        }
+
+        public static void set_default_device(string device)
+        {
+            set_default_device(new Device(device));
+        }
+
         // https://pytorch.org/docs/stable/generated/torch.numel
         /// <summary>
         /// Get the number of elements in the input tensor.

src/TorchSharp/Torch.cs

@@ -298,8 +298,10 @@ public static void InitializeDeviceType(DeviceType deviceType)
 
         public static Device InitializeDevice(Device? device)
         {
-            if (device == null)
-                device = new Device(DeviceType.CPU, -1);
+            if (device is null)
+            {
+                device = get_default_device();
+            }
             InitializeDeviceType(device.type);
             return device;
         }

test/TorchSharpTest/TestTorchTensor.cs

@@ -8375,5 +8375,67 @@ public void TestSaveAndLoadModuleWithLarger2GBTensorCUDA()
                 }
             }
         }
+
+        [Fact]
+        public void DefaultDTypeCreation()
+        {
+            var dt = torch.get_default_dtype();
+
+            var t = torch.zeros(5,5);
+            Assert.Equal(torch.float32, t.dtype);
+
+            try {
+                torch.set_default_dtype(torch.float64);              
+                
+                t = torch.zeros(5,5);
+                Assert.Equal(torch.float64, t.dtype);
+
+                t = torch.ones(5,5);
+                Assert.Equal(torch.float64, t.dtype);
+
+                t = torch.rand(5,5);
+                Assert.Equal(torch.float64, t.dtype);
+
+                t = torch.randn(5,5);
+                Assert.Equal(torch.float64, t.dtype);
+
+                t = torch.logspace(5, 15, 20);
+                Assert.Equal(torch.float64, t.dtype);
+            }
+            finally {
+                torch.set_default_dtype(dt);
+            }
+        }
+
+        [Fact]
+        public void DefaultDeviceCreation()
+        {
+            var dt = torch.get_default_device();
+
+            var t = torch.zeros(5,5);
+            Assert.Equal(DeviceType.CPU, t.device_type);
+
+            try {
+                torch.set_default_device(torch.META);              
+                
+                t = torch.zeros(5,5);
+                Assert.Equal(DeviceType.META, t.device_type);
+
+                t = torch.ones(5,5);
+                Assert.Equal(DeviceType.META, t.device_type);
+
+                t = torch.rand(5,5);
+                Assert.Equal(DeviceType.META, t.device_type);
+
+                t = torch.randn(5,5);
+                Assert.Equal(DeviceType.META, t.device_type);
+
+                t = torch.logspace(5, 15, 20);
+                Assert.Equal(DeviceType.META, t.device_type);
+            }
+            finally {
+                torch.set_default_device(dt);
+            }
+        }
     }
 }