.. _sec_ndarray:
Thao tác dữ liệu
================
Để hoàn thành bất cứ điều gì, chúng ta cần một số cách để lưu trữ và
thao tác dữ liệu. Nói chung, có hai điều quan trọng chúng ta cần làm với
dữ liệu: (i) có được chúng; và (ii) xử lý chúng một khi chúng ở trong
máy tính. Không có điểm nào trong việc thu thập dữ liệu mà không cần một
cách nào đó để lưu trữ nó, vì vậy hãy để chúng tôi làm bẩn tay trước
bằng cách chơi với dữ liệu tổng hợp. Để bắt đầu, chúng tôi giới thiệu
mảng :math:`n` chiều, còn được gọi là \* tensor\*.
Nếu bạn đã làm việc với NumPy, gói máy tính khoa học được sử dụng rộng
rãi nhất trong Python, thì bạn sẽ thấy phần này quen thuộc. Cho dù bạn
sử dụng khung nào, lớp tensor\* của nó\* (``ndarray`` trong MXNet,
``Tensor`` trong cả PyTorch và TensorFlow) tương tự như ``ndarray`` của
NumPy với một vài tính năng giết người. Đầu tiên, GPU được hỗ trợ tốt để
tăng tốc tính toán trong khi NumPy chỉ hỗ trợ tính toán CPU. Thứ hai,
lớp tensor hỗ trợ sự khác biệt tự động. Những tính chất này làm cho lớp
tensor phù hợp với học sâu. Trong suốt cuốn sách, khi chúng tôi nói hàng
chục, chúng tôi đang đề cập đến các trường hợp của lớp tensor trừ khi có
quy định khác.
Bắt đầu
-------
Trong phần này, chúng tôi mong muốn giúp bạn hoạt động, trang bị cho bạn
các công cụ toán học và tính toán số cơ bản mà bạn sẽ xây dựng khi bạn
tiến bộ qua cuốn sách. Đừng lo lắng nếu bạn đấu tranh để grok một số
khái niệm toán học hoặc chức năng thư viện. Các phần sau đây sẽ xem xét
lại tài liệu này trong bối cảnh các ví dụ thực tế và nó sẽ chìm vào. Mặt
khác, nếu bạn đã có một số nền tảng và muốn đi sâu hơn vào nội dung toán
học, chỉ cần bỏ qua phần này.
.. raw:: html
.. raw:: html
Để bắt đầu, chúng tôi nhập các mô-đun ``np`` (``numpy``) và ``npx``
(``numpy_extension``) từ MXNet. Ở đây, mô-đun ``np`` bao gồm các chức
năng được hỗ trợ bởi NumPy, trong khi mô-đun ``npx`` chứa một tập hợp
các phần mở rộng được phát triển để trao quyền cho việc học sâu trong
một môi trường giống như NumPy-like. Khi sử dụng hàng chục, chúng tôi
hầu như luôn gọi hàm ``set_np``: đây là để tương thích xử lý tensor bởi
các thành phần khác của MXNet.
.. code:: python
from mxnet import np, npx
npx.set_np()
.. raw:: html
.. raw:: html
Để bắt đầu, chúng tôi nhập ``torch``. Lưu ý rằng mặc dù nó được gọi là
PyTorch, chúng ta nên nhập ``torch`` thay vì ``pytorch``.
.. code:: python
import torch
.. raw:: html
.. raw:: html
Để bắt đầu, chúng tôi nhập ``tensorflow``. Vì tên dài một chút, chúng ta
thường nhập nó với một bí danh ngắn ``tf``.
.. code:: python
import tensorflow as tf
.. raw:: html
.. raw:: html
.. raw:: html
MXNet cung cấp một loạt các chức năng để tạo ra các hàng chục mới
prepopulated với các giá trị. Ví dụ, bằng cách gọi ``arange(n)``, chúng
ta có thể tạo một vectơ có giá trị cách đều nhau, bắt đầu từ 0 (bao gồm)
và kết thúc ở ``n`` (không bao gồm). Theo mặc định, kích thước khoảng
thời gian là :math:`1`. Trừ khi có quy định khác, hàng chục mới được lưu
trữ trong bộ nhớ chính và được chỉ định cho tính toán dựa trên CPU.
.. code:: python
x = np.arange(12)
x
.. parsed-literal::
:class: output
array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11.])
.. raw:: html
.. raw:: html
PyTorch cung cấp một loạt các chức năng để tạo ra các hàng chục mới
prepopulated với các giá trị. Ví dụ, bằng cách gọi ``arange(n)``, chúng
ta có thể tạo một vectơ có giá trị cách đều nhau, bắt đầu từ 0 (bao gồm)
và kết thúc ở ``n`` (không bao gồm). Theo mặc định, kích thước khoảng
thời gian là :math:`1`. Trừ khi có quy định khác, hàng chục mới được lưu
trữ trong bộ nhớ chính và được chỉ định cho tính toán dựa trên CPU.
.. code:: python
x = torch.arange(12, dtype=torch.float32)
x
.. parsed-literal::
:class: output
tensor([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11.])
.. raw:: html
.. raw:: html
TensorFlow cung cấp một loạt các chức năng để tạo ra các hàng chục mới
prepopulated với các giá trị. Ví dụ, bằng cách gọi ``range(n)``, chúng
ta có thể tạo một vectơ có giá trị cách đều nhau, bắt đầu từ 0 (bao gồm)
và kết thúc ở ``n`` (không bao gồm). Theo mặc định, kích thước khoảng
thời gian là :math:`1`. Trừ khi có quy định khác, hàng chục mới được lưu
trữ trong bộ nhớ chính và được chỉ định cho tính toán dựa trên CPU.
.. code:: python
x = tf.range(12, dtype=tf.float32)
x
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
x.shape
.. parsed-literal::
:class: output
(12,)
.. raw:: html
.. raw:: html
.. code:: python
x.shape
.. parsed-literal::
:class: output
torch.Size([12])
.. raw:: html
.. raw:: html
.. code:: python
x.shape
.. parsed-literal::
:class: output
TensorShape([12])
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
x.size
.. parsed-literal::
:class: output
12
.. raw:: html
.. raw:: html
.. code:: python
x.numel()
.. parsed-literal::
:class: output
12
.. raw:: html
.. raw:: html
.. code:: python
tf.size(x)
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
X = x.reshape(3, 4)
X
.. parsed-literal::
:class: output
array([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]])
.. raw:: html
.. raw:: html
.. code:: python
X = x.reshape(3, 4)
X
.. parsed-literal::
:class: output
tensor([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]])
.. raw:: html
.. raw:: html
.. code:: python
X = tf.reshape(x, (3, 4))
X
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
np.zeros((2, 3, 4))
.. parsed-literal::
:class: output
array([[[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]],
[[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]]])
.. raw:: html
.. raw:: html
.. code:: python
torch.zeros((2, 3, 4))
.. parsed-literal::
:class: output
tensor([[[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]],
[[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]]])
.. raw:: html
.. raw:: html
.. code:: python
tf.zeros((2, 3, 4))
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
np.ones((2, 3, 4))
.. parsed-literal::
:class: output
array([[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]]])
.. raw:: html
.. raw:: html
.. code:: python
torch.ones((2, 3, 4))
.. parsed-literal::
:class: output
tensor([[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]],
[[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]]])
.. raw:: html
.. raw:: html
.. code:: python
tf.ones((2, 3, 4))
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
np.random.normal(0, 1, size=(3, 4))
.. parsed-literal::
:class: output
array([[ 2.2122064 , 1.1630787 , 0.7740038 , 0.4838046 ],
[ 1.0434403 , 0.29956347, 1.1839255 , 0.15302546],
[ 1.8917114 , -1.1688148 , -1.2347414 , 1.5580711 ]])
.. raw:: html
.. raw:: html
.. code:: python
torch.randn(3, 4)
.. parsed-literal::
:class: output
tensor([[-0.6519, 0.2903, 1.9321, -0.7751],
[ 1.2866, -0.1815, 1.2278, 1.9197],
[-0.1778, 0.3601, 0.6502, -0.0875]])
.. raw:: html
.. raw:: html
.. code:: python
tf.random.normal(shape=[3, 4])
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
np.array([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
.. parsed-literal::
:class: output
array([[2., 1., 4., 3.],
[1., 2., 3., 4.],
[4., 3., 2., 1.]])
.. raw:: html
.. raw:: html
.. code:: python
torch.tensor([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
.. parsed-literal::
:class: output
tensor([[2, 1, 4, 3],
[1, 2, 3, 4],
[4, 3, 2, 1]])
.. raw:: html
.. raw:: html
.. code:: python
tf.constant([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
x = np.array([1, 2, 4, 8])
y = np.array([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y # The ** operator is exponentiation
.. parsed-literal::
:class: output
(array([ 3., 4., 6., 10.]),
array([-1., 0., 2., 6.]),
array([ 2., 4., 8., 16.]),
array([0.5, 1. , 2. , 4. ]),
array([ 1., 4., 16., 64.]))
.. raw:: html
.. raw:: html
.. code:: python
x = torch.tensor([1.0, 2, 4, 8])
y = torch.tensor([2, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y # The ** operator is exponentiation
.. parsed-literal::
:class: output
(tensor([ 3., 4., 6., 10.]),
tensor([-1., 0., 2., 6.]),
tensor([ 2., 4., 8., 16.]),
tensor([0.5000, 1.0000, 2.0000, 4.0000]),
tensor([ 1., 4., 16., 64.]))
.. raw:: html
.. raw:: html
.. code:: python
x = tf.constant([1.0, 2, 4, 8])
y = tf.constant([2.0, 2, 2, 2])
x + y, x - y, x * y, x / y, x ** y # The ** operator is exponentiation
.. parsed-literal::
:class: output
(,
,
,
,
)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
np.exp(x)
.. parsed-literal::
:class: output
array([2.7182817e+00, 7.3890562e+00, 5.4598148e+01, 2.9809580e+03])
.. raw:: html
.. raw:: html
.. code:: python
torch.exp(x)
.. parsed-literal::
:class: output
tensor([2.7183e+00, 7.3891e+00, 5.4598e+01, 2.9810e+03])
.. raw:: html
.. raw:: html
.. code:: python
tf.exp(x)
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
X = np.arange(12).reshape(3, 4)
Y = np.array([[2, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
np.concatenate([X, Y], axis=0), np.concatenate([X, Y], axis=1)
.. parsed-literal::
:class: output
(array([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[ 2., 1., 4., 3.],
[ 1., 2., 3., 4.],
[ 4., 3., 2., 1.]]),
array([[ 0., 1., 2., 3., 2., 1., 4., 3.],
[ 4., 5., 6., 7., 1., 2., 3., 4.],
[ 8., 9., 10., 11., 4., 3., 2., 1.]]))
.. raw:: html
.. raw:: html
.. code:: python
X = torch.arange(12, dtype=torch.float32).reshape((3,4))
Y = torch.tensor([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
torch.cat((X, Y), dim=0), torch.cat((X, Y), dim=1)
.. parsed-literal::
:class: output
(tensor([[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[ 2., 1., 4., 3.],
[ 1., 2., 3., 4.],
[ 4., 3., 2., 1.]]),
tensor([[ 0., 1., 2., 3., 2., 1., 4., 3.],
[ 4., 5., 6., 7., 1., 2., 3., 4.],
[ 8., 9., 10., 11., 4., 3., 2., 1.]]))
.. raw:: html
.. raw:: html
.. code:: python
X = tf.reshape(tf.range(12, dtype=tf.float32), (3, 4))
Y = tf.constant([[2.0, 1, 4, 3], [1, 2, 3, 4], [4, 3, 2, 1]])
tf.concat([X, Y], axis=0), tf.concat([X, Y], axis=1)
.. parsed-literal::
:class: output
(,
)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
X == Y
.. parsed-literal::
:class: output
array([[False, True, False, True],
[False, False, False, False],
[False, False, False, False]])
.. raw:: html
.. raw:: html
.. code:: python
X == Y
.. parsed-literal::
:class: output
tensor([[False, True, False, True],
[False, False, False, False],
[False, False, False, False]])
.. raw:: html
.. raw:: html
.. code:: python
X == Y
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
X.sum()
.. parsed-literal::
:class: output
array(66.)
.. raw:: html
.. raw:: html
.. code:: python
X.sum()
.. parsed-literal::
:class: output
tensor(66.)
.. raw:: html
.. raw:: html
.. code:: python
tf.reduce_sum(X)
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
a = np.arange(3).reshape(3, 1)
b = np.arange(2).reshape(1, 2)
a, b
.. parsed-literal::
:class: output
(array([[0.],
[1.],
[2.]]),
array([[0., 1.]]))
.. raw:: html
.. raw:: html
.. code:: python
a = torch.arange(3).reshape((3, 1))
b = torch.arange(2).reshape((1, 2))
a, b
.. parsed-literal::
:class: output
(tensor([[0],
[1],
[2]]),
tensor([[0, 1]]))
.. raw:: html
.. raw:: html
.. code:: python
a = tf.reshape(tf.range(3), (3, 1))
b = tf.reshape(tf.range(2), (1, 2))
a, b
.. parsed-literal::
:class: output
(,
)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
a + b
.. parsed-literal::
:class: output
array([[0., 1.],
[1., 2.],
[2., 3.]])
.. raw:: html
.. raw:: html
.. code:: python
a + b
.. parsed-literal::
:class: output
tensor([[0, 1],
[1, 2],
[2, 3]])
.. raw:: html
.. raw:: html
.. code:: python
a + b
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
X[-1], X[1:3]
.. parsed-literal::
:class: output
(array([ 8., 9., 10., 11.]),
array([[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]]))
Ngoài việc đọc, chúng ta cũng có thể viết các phần tử của ma trận bằng
cách chỉ định các chỉ số.
.. code:: python
X[1, 2] = 9
X
.. parsed-literal::
:class: output
array([[ 0., 1., 2., 3.],
[ 4., 5., 9., 7.],
[ 8., 9., 10., 11.]])
.. raw:: html
.. raw:: html
.. code:: python
X[-1], X[1:3]
.. parsed-literal::
:class: output
(tensor([ 8., 9., 10., 11.]),
tensor([[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]]))
Ngoài việc đọc, chúng ta cũng có thể viết các phần tử của ma trận bằng
cách chỉ định các chỉ số.
.. code:: python
X[1, 2] = 9
X
.. parsed-literal::
:class: output
tensor([[ 0., 1., 2., 3.],
[ 4., 5., 9., 7.],
[ 8., 9., 10., 11.]])
.. raw:: html
.. raw:: html
.. code:: python
X[-1], X[1:3]
.. parsed-literal::
:class: output
(,
)
``Tensors`` trong TensorFlow là bất biến và không thể được gán cho.
``Variables`` trong TensorFlow là các thùng chứa có thể thay đổi của
trạng thái hỗ trợ các bài tập. Hãy nhớ rằng độ dốc trong TensorFlow
không chảy ngược qua các bài tập ``Variable``.
Ngoài việc gán một giá trị cho toàn bộ ``Variable``, chúng ta có thể
viết các phần tử của ``Variable`` bằng cách chỉ định các chỉ số.
.. code:: python
X_var = tf.Variable(X)
X_var[1, 2].assign(9)
X_var
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
X[0:2, :] = 12
X
.. parsed-literal::
:class: output
array([[12., 12., 12., 12.],
[12., 12., 12., 12.],
[ 8., 9., 10., 11.]])
.. raw:: html
.. raw:: html
.. code:: python
X[0:2, :] = 12
X
.. parsed-literal::
:class: output
tensor([[12., 12., 12., 12.],
[12., 12., 12., 12.],
[ 8., 9., 10., 11.]])
.. raw:: html
.. raw:: html
.. code:: python
X_var = tf.Variable(X)
X_var[0:2, :].assign(tf.ones(X_var[0:2,:].shape, dtype = tf.float32) * 12)
X_var
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
before = id(Y)
Y = Y + X
id(Y) == before
.. parsed-literal::
:class: output
False
.. raw:: html
.. raw:: html
.. code:: python
before = id(Y)
Y = Y + X
id(Y) == before
.. parsed-literal::
:class: output
False
.. raw:: html
.. raw:: html
.. code:: python
before = id(Y)
Y = Y + X
id(Y) == before
.. parsed-literal::
:class: output
False
.. raw:: html
.. raw:: html
.. raw:: html
May mắn thay, thực hiện hoạt động tại chỗ rất dễ dàng. Chúng ta có thể
gán kết quả của một hoạt động cho một mảng được phân bổ trước đó với ký
hiệu slice, ví dụ, ``Y[:] = ``. Để minh họa khái niệm này,
trước tiên chúng ta tạo ra một ma trận mới ``Z`` với hình dạng tương tự
như ``Y`` khác, sử dụng ``zeros_like`` để phân bổ một khối :math:`0` mục
nhập.
.. code:: python
Z = np.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))
.. parsed-literal::
:class: output
id(Z): 139999247991872
id(Z): 139999247991872
Nếu giá trị của ``X`` không được sử dụng lại trong các tính toán tiếp
theo, chúng ta cũng có thể sử dụng ``X[:] = X + Y`` hoặc ``X += Y`` để
giảm chi phí bộ nhớ của hoạt động.
.. code:: python
before = id(X)
X += Y
id(X) == before
.. parsed-literal::
:class: output
True
.. raw:: html
.. raw:: html
May mắn thay, thực hiện hoạt động tại chỗ rất dễ dàng. Chúng ta có thể
gán kết quả của một hoạt động cho một mảng được phân bổ trước đó với ký
hiệu slice, ví dụ, ``Y[:] = ``. Để minh họa khái niệm này,
trước tiên chúng ta tạo ra một ma trận mới ``Z`` với hình dạng tương tự
như ``Y`` khác, sử dụng ``zeros_like`` để phân bổ một khối :math:`0` mục
nhập.
.. code:: python
Z = torch.zeros_like(Y)
print('id(Z):', id(Z))
Z[:] = X + Y
print('id(Z):', id(Z))
.. parsed-literal::
:class: output
id(Z): 140201478059168
id(Z): 140201478059168
Nếu giá trị của ``X`` không được sử dụng lại trong các tính toán tiếp
theo, chúng ta cũng có thể sử dụng ``X[:] = X + Y`` hoặc ``X += Y`` để
giảm chi phí bộ nhớ của hoạt động.
.. code:: python
before = id(X)
X += Y
id(X) == before
.. parsed-literal::
:class: output
True
.. raw:: html
.. raw:: html
``Variables`` là các thùng chứa có thể thay đổi trạng thái trong
TensorFlow. Họ cung cấp một cách để lưu trữ các thông số mô hình của
bạn. Chúng ta có thể gán kết quả của một hoạt động cho một ``Variable``
với ``assign``. Để minh họa khái niệm này, chúng tôi tạo ra một
``Variable`` ``Z`` với hình dạng tương tự như một tensor ``Y``, sử dụng
``zeros_like`` để phân bổ một khối :math:`0` mục nhập.
.. code:: python
Z = tf.Variable(tf.zeros_like(Y))
print('id(Z):', id(Z))
Z.assign(X + Y)
print('id(Z):', id(Z))
.. parsed-literal::
:class: output
id(Z): 139638297808960
id(Z): 139638297808960
Ngay cả khi bạn lưu trữ trạng thái liên tục trong ``Variable``, bạn có
thể muốn giảm mức sử dụng bộ nhớ của mình hơn nữa bằng cách tránh phân
bổ dư thừa cho hàng chục không phải là tham số mô hình của bạn.
Bởi vì TensorFlow ``Tensors`` là bất biến và gradient không chảy qua các
bài tập ``Variable``, TensorFlow không cung cấp một cách rõ ràng để chạy
một hoạt động riêng lẻ tại chỗ.
Tuy nhiên, TensorFlow cung cấp trình trang trí ``tf.function`` để gói
tính toán bên trong đồ thị TensorFlow được biên dịch và tối ưu hóa trước
khi chạy. Điều này cho phép TensorFlow cắt tỉa các giá trị chưa sử dụng
và sử dụng lại các phân bổ trước đó không còn cần thiết nữa. Điều này
giảm thiểu chi phí bộ nhớ của tính toán TensorFlow.
.. code:: python
@tf.function
def computation(X, Y):
Z = tf.zeros_like(Y) # This unused value will be pruned out
A = X + Y # Allocations will be re-used when no longer needed
B = A + Y
C = B + Y
return C + Y
computation(X, Y)
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
Chuyển đổi sang tensor NumPy (``ndarray``) , hoặc ngược lại, rất dễ
dàng. Kết quả được chuyển đổi không chia sẻ bộ nhớ. Sự bất tiện nhỏ này
thực sự khá quan trọng: khi bạn thực hiện các thao tác trên CPU hoặc
trên GPU, bạn không muốn tạm dừng tính toán, chờ xem liệu gói NumPy của
Python có thể muốn làm một cái gì đó khác với cùng một đoạn bộ nhớ hay
không.
.. code:: python
A = X.asnumpy()
B = np.array(A)
type(A), type(B)
.. parsed-literal::
:class: output
(numpy.ndarray, mxnet.numpy.ndarray)
.. raw:: html
.. raw:: html
Chuyển đổi sang tensor NumPy (``ndarray``) , hoặc ngược lại, rất dễ
dàng. Ngọn đuốc Tensor và mảng numpy sẽ chia sẻ vị trí bộ nhớ cơ bản của
chúng, và thay đổi một thông qua một hoạt động tại chỗ cũng sẽ thay đổi
vị trí khác.
.. code:: python
A = X.numpy()
B = torch.from_numpy(A)
type(A), type(B)
.. parsed-literal::
:class: output
(numpy.ndarray, torch.Tensor)
.. raw:: html
.. raw:: html
Chuyển đổi sang tensor NumPy (``ndarray``) , hoặc ngược lại, rất dễ
dàng. Kết quả được chuyển đổi không chia sẻ bộ nhớ. Sự bất tiện nhỏ này
thực sự khá quan trọng: khi bạn thực hiện các thao tác trên CPU hoặc
trên GPU, bạn không muốn tạm dừng tính toán, chờ xem liệu gói NumPy của
Python có thể muốn làm một cái gì đó khác với cùng một đoạn bộ nhớ hay
không.
.. code:: python
A = X.numpy()
B = tf.constant(A)
type(A), type(B)
.. parsed-literal::
:class: output
(numpy.ndarray, tensorflow.python.framework.ops.EagerTensor)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
a = np.array([3.5])
a, a.item(), float(a), int(a)
.. parsed-literal::
:class: output
(array([3.5]), 3.5, 3.5, 3)
.. raw:: html
.. raw:: html
.. code:: python
a = torch.tensor([3.5])
a, a.item(), float(a), int(a)
.. parsed-literal::
:class: output
(tensor([3.5000]), 3.5, 3.5, 3)
.. raw:: html
.. raw:: html
.. code:: python
a = tf.constant([3.5]).numpy()
a, a.item(), float(a), int(a)
.. parsed-literal::
:class: output
(array([3.5], dtype=float32), 3.5, 3.5, 3)
.. raw:: html
.. raw:: html
.. raw:: html
`Discussions `__
.. raw:: html
.. raw:: html
`Discussions `__
.. raw:: html
.. raw:: html
`Discussions `__
.. raw:: html
.. raw:: html