public static TorchTensor matrix_rank(TorchTensor input, double?tol = null, bool hermitian = false)
{
unsafe {
var res = THSLinalg_matrix_rank(input.Handle, tol ?? double.NegativeInfinity, tol.HasValue, hermitian);
if (res == IntPtr.Zero)
{
Torch.CheckForErrors();
}
return(new TorchTensor(res));
}
}
public void TestCatCuda()
{
if (Torch.IsCudaAvailable())
{
var zeros = FloatTensor.Zeros(new long[] { 1, 9 }).Cuda();
var ones = FloatTensor.Ones(new long[] { 1, 9 }).Cuda();
var centroids = new TorchTensor[] { zeros, ones }.Cat(0);
var shape = centroids.Shape;
Assert.Equal(new long[] { 2, 9 }, shape);
Assert.Equal(DeviceType.CUDA, centroids.DeviceType);
}
}
public void ValidateIssue145()
{
// TorchTensor.DataItem gives a hard crash on GPU tensor
if (Torch.IsCudaAvailable())
{
var scalar = Float32Tensor.from(3.14f, Device.CUDA);
Assert.Throws <InvalidOperationException>(() => scalar.DataItem <float>());
var tensor = Float32Tensor.zeros(new long[] { 10, 10 }, Device.CUDA);
Assert.Throws <InvalidOperationException>(() => tensor.Data <float>());
Assert.Throws <InvalidOperationException>(() => tensor.Bytes());
}
}
public void TestTrainingConv2dCUDA()
{
if (Torch.IsCudaAvailable())
{
var device = Device.CUDA;
using (Module conv1 = Conv2d(3, 4, 3, stride: 2),
lin1 = Linear(4 * 13 * 13, 32),
lin2 = Linear(32, 10))
using (var seq = Sequential(
("conv1", conv1),
("r1", ReLU(inPlace: true)),
("drop1", Dropout(0.1)),
("flat1", Flatten()),
("lin1", lin1),
("r2", ReLU(inPlace: true)),
("lin2", lin2))) {
seq.to(device);
var optimizer = NN.Optimizer.Adam(seq.parameters());
var loss = mse_loss(NN.Reduction.Sum);
using (TorchTensor x = Float32Tensor.randn(new long[] { 64, 3, 28, 28 }, device: device),
y = Float32Tensor.randn(new long[] { 64, 10 }, device: device)) {
float initialLoss = loss(seq.forward(x), y).ToSingle();
float finalLoss = float.MaxValue;
for (int i = 0; i < 10; i++)
{
var eval = seq.forward(x);
var output = loss(eval, y);
var lossVal = output.ToSingle();
finalLoss = lossVal;
optimizer.zero_grad();
output.backward();
optimizer.step();
}
Assert.True(finalLoss < initialLoss);
}
}
}
else
{
Assert.Throws <InvalidOperationException>(() => Float32Tensor.randn(new long[] { 64, 3, 28, 28 }).cuda());
}
}
public static TorchTensor tensorsolve(TorchTensor input, TorchTensor other, long[] dims)
{
unsafe
{
fixed(long *pdims = dims)
{
var res = THSLinalg_tensorsolve(input.Handle, other.Handle, (IntPtr)pdims, dims.Length);
if (res == IntPtr.Zero)
{
Torch.CheckForErrors();
}
return(new TorchTensor(res));
}
}
}
public static TorchTensor norm(TorchTensor input, long[]?dims = null, bool keepdim = false)
{
unsafe
{
fixed(long *pdims = dims)
{
var res = THSLinalg_norm_opt(input.Handle, (IntPtr)pdims, dims is null ? 0 : dims.Length, keepdim);
if (res == IntPtr.Zero)
{
Torch.CheckForErrors();
}
return(new TorchTensor(res));
}
}
}
public void TestExplicitGenerators()
{
// This tests that the default generator can be disposed, but will keep on going.
lock (_lock) {
long a, b, c;
using (var gen = Torch.ManualSeed(4711)) {
a = gen.InitialSeed;
}
using (TorchGenerator gen = TorchGenerator.Default, genA = new TorchGenerator(4355)) {
b = gen.InitialSeed;
c = genA.InitialSeed;
}
Assert.Equal(a, b);
Assert.NotEqual(a, c);
Assert.Equal(4355, c);
}
}
public void CopyCudaToCpu()
{
if (Torch.IsCudaAvailable())
{
var cuda = FloatTensor.Ones(new long[] { 2, 2 }, DeviceType.CUDA);
Assert.Equal("cuda:0", cuda.DeviceString);
var cpu = cuda.Cpu();
Assert.Equal("cpu", cpu.DeviceString);
var data = cpu.Data <float>();
for (int i = 0; i < 4; i++)
{
Assert.Equal(1, data[i]);
}
}
else
{
Assert.Throws <InvalidOperationException>(() => { FloatTensor.Ones(new long[] { 2, 2 }, DeviceType.CUDA); });
}
}
public void TestDefaultGenerators()
{
// This tests that the default generator can be disposed, but will keep on going,
long a, b, c;
lock (_lock) {
using (var gen = Torch.ManualSeed(4711)) {
a = gen.InitialSeed;
}
using (var gen = TorchGenerator.Default) {
b = gen.InitialSeed;
}
Assert.Equal(a, b);
using (var gen = Torch.ManualSeed(17)) {
c = gen.InitialSeed;
}
Assert.NotEqual(a, c);
var x = Float32Tensor.rand(new long[] { 10, 10, 10 });
Assert.Equal(new long[] { 10, 10, 10 }, x.shape);
}
}
public void TestGeneratorState()
{
// This test fails intermittently with CUDA. Just skip it.
if (Torch.IsCudaAvailable())
{
return;
}
// After restoring a saved RNG state, the next number should be the
// same as right after the snapshot.
lock (_lock) {
using (var gen = Torch.ManualSeed(4711)) {
// Take a snapshot
var state = gen.State;
Assert.NotNull(state);
// Generate a number
var val1 = Float32Tensor.randn(new long[] { 1 });
var value1 = val1[0].ToSingle();
// Genereate a different number
var val2 = Float32Tensor.randn(new long[] { 1 });
var value2 = val2[0].ToSingle();
Assert.NotEqual(value1, value2);
// Restore the state
gen.State = state;
// Generate the first number again.
var val3 = Float32Tensor.randn(new long[] { 1 });
var value3 = val3[0].ToSingle();
Assert.Equal(value1, value3);
}
}
}
public void TestDeviceCount()
{
//var shape = new long[] { 2, 2 };
var isCudaAvailable = Torch.IsCudaAvailable();
var isCudnnAvailable = Torch.IsCudnnAvailable();
var deviceCount = Torch.CudaDeviceCount();
if (isCudaAvailable)
{
Assert.True(deviceCount > 0);
Assert.True(isCudnnAvailable);
}
else
{
Assert.Equal(0, deviceCount);
Assert.False(isCudnnAvailable);
}
//TorchTensor t = Float32Tensor.ones(shape);
//Assert.Equal(shape, t.Shape);
//Assert.Equal(1.0f, t[0, 0].ToSingle());
//Assert.Equal(1.0f, t[1, 1].ToSingle());
}
public TorchGenerator ManualSeed(long seed)
{
Torch.TryInitializeDeviceType(DeviceType.CUDA);
THSGenerator_gen_manual_seed(Handle, seed);
return(this);
}
