[ad_1]
WHAT IS PYTORCH?
It’s a Python-based scientific computing package targeted at two sets of audiences:
- A replacement for NumPy to use the power of GPUs
- a deep learning research platform that provides maximum flexibility and speed
Getting Started
Tensors
Tensors are similar to NumPy’s ndarrays, with the addition being that Tensors can also be used on a GPU to accelerate computing.
from __future__ import print_function import torch
NOTE
An uninitialized matrix is declared, but does not contain definite known values before it is used. When an uninitialized matrix is created, whatever values were in the allocated memory at the time will appear as the initial values.
Construct a 5×3 matrix, uninitialized:
x = torch.empty(5, 3) print(x)
Out:
tensor([[ 2.1660e+35, 4.5808e-41, -2.4203e+15],
[ 3.0655e-41, 0.0000e+00, 1.4013e-45],
[ 0.0000e+00, 0.0000e+00, 0.0000e+00],
[ 0.0000e+00, 0.0000e+00, 0.0000e+00],
[ 0.0000e+00, 0.0000e+00, 0.0000e+00]])
Construct a randomly initialized matrix:
x = torch.rand(5, 3) print(x)
Out:
tensor([[0.4707, 0.7056, 0.8309],
[0.3842, 0.7964, 0.8027],
[0.1584, 0.0038, 0.0977],
[0.3735, 0.5157, 0.2004],
[0.3184, 0.5997, 0.1331]])
Construct a matrix filled zeros and of dtype long:
x = torch.zeros(5, 3, dtype=torch.long) print(x)
Out:
tensor([[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0],
[0, 0, 0]])
Construct a tensor directly from data:
x = torch.tensor([5.5, 3]) print(x)
Out:
tensor([5.5000, 3.0000])
or create a tensor based on an existing tensor. These methods will reuse properties of the input tensor, e.g. dtype, unless new values are provided by user
x = x.new_ones(5, 3, dtype=torch.double) # new_* methods take in sizes print(x) x = torch.randn_like(x, dtype=torch.float) # override dtype! print(x) # result has the same size
Out:
tensor([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]], dtype=torch.float64)
tensor([[-1.1635, -1.0563, -0.7356],
[ 0.0370, -1.5329, 0.4804],
[-0.9072, 0.0670, 0.1239],
[ 0.4044, 3.2442, 0.3095],
[ 1.0097, -0.2127, -0.1874]])
Get its size:
print(x.size())
Out:
torch.Size([5, 3])
NOTE
torch.Size is in fact a tuple, so it supports all tuple operations.
Operations
There are multiple syntaxes for operations. In the following example, we will take a look at the addition operation.
Addition: syntax 1
y = torch.rand(5, 3) print(x + y)
Out:
tensor([[-0.7917, -0.7639, 0.0503],
[ 0.4106, -0.6558, 1.2802],
[-0.4236, 0.8598, 0.2997],
[ 0.6906, 4.1633, 1.1647],
[ 1.9392, 0.5870, 0.0440]])
Addition: syntax 2
print(torch.add(x, y))
Out:
tensor([[-0.7917, -0.7639, 0.0503],
[ 0.4106, -0.6558, 1.2802],
[-0.4236, 0.8598, 0.2997],
[ 0.6906, 4.1633, 1.1647],
[ 1.9392, 0.5870, 0.0440]])
Addition: providing an output tensor as argument
result = torch.empty(5, 3) torch.add(x, y, out=result) print(result)
Out:
tensor([[-0.7917, -0.7639, 0.0503],
[ 0.4106, -0.6558, 1.2802],
[-0.4236, 0.8598, 0.2997],
[ 0.6906, 4.1633, 1.1647],
[ 1.9392, 0.5870, 0.0440]])
Addition: in-place
# adds x to y y.add_(x) print(y)
Out:
tensor([[-0.7917, -0.7639, 0.0503],
[ 0.4106, -0.6558, 1.2802],
[-0.4236, 0.8598, 0.2997],
[ 0.6906, 4.1633, 1.1647],
[ 1.9392, 0.5870, 0.0440]])
NOTE
Any operation that mutates a tensor in-place is post-fixed with an _. For example: x.copy_(y), x.t_(), will change x.
You can use standard NumPy-like indexing with all bells and whistles!
print(x[:, 1])
Out:
tensor([-1.0563, -1.5329, 0.0670, 3.2442, -0.2127])
Resizing: If you want to resize/reshape tensor, you can use torch.view:
x = torch.randn(4, 4) y = x.view(16) z = x.view(-1, 8) # the size -1 is inferred from other dimensions print(x.size(), y.size(), z.size())
Out:
torch.Size([4, 4]) torch.Size([16]) torch.Size([2, 8])
If you have a one element tensor, use .item() to get the value as a Python number
x = torch.randn(1) print(x) print(x.item())
Out:
tensor([-1.0658]) -1.0657769441604614
Read later:100+ Tensor operations, including transposing, indexing, slicing, mathematical operations, linear algebra, random numbers, etc., are described here.
NumPy Bridge
Converting a Torch Tensor to a NumPy array and vice versa is a breeze.
The Torch Tensor and NumPy array will share their underlying memory locations (if the Torch Tensor is on CPU), and changing one will change the other.
Converting a Torch Tensor to a NumPy Array
a = torch.ones(5) print(a)
Out:
tensor([1., 1., 1., 1., 1.])
b = a.numpy() print(b)
Out:
[1. 1. 1. 1. 1.]
See how the numpy array changed in value.
a.add_(1) print(a) print(b)
Out:
tensor([2., 2., 2., 2., 2.]) [2. 2. 2. 2. 2.]
Converting NumPy Array to Torch Tensor
See how changing the np array changed the Torch Tensor automatically
import numpy as np a = np.ones(5) b = torch.from_numpy(a) np.add(a, 1, out=a) print(a) print(b)
Out:
[2. 2. 2. 2. 2.] tensor([2., 2., 2., 2., 2.], dtype=torch.float64)
All the Tensors on the CPU except a CharTensor support converting to NumPy and back.
CUDA Tensors
Tensors can be moved onto any device using the .to method.
# let us run this cell only if CUDA is available
# We will use ``torch.device`` objects to move tensors in and out of GPU
if torch.cuda.is_available():
device = torch.device("cuda") # a CUDA device object
y = torch.ones_like(x, device=device) # directly create a tensor on GPU
x = x.to(device) # or just use strings ``.to("cuda")``
z = x + y
print(z)
print(z.to("cpu", torch.double)) # ``.to`` can also change dtype together!
Out:
tensor([-0.0658], device='cuda:0') tensor([-0.0658], dtype=torch.float64)
[ad_2]
This article has been published from the source link without modifications to the text. Only the deadline has been changed.
Source link
