このページは Cloud Translation API によって翻訳されました。
Switch to English

テンソルの概要

TensorFlow.org上に表示します Googleのコラボで実行します GitHubの上のソースを表示 ダウンロードノート
 import tensorflow as tf
import numpy as np
 

テンソルは(と呼ばれる均一なタイプの多次元配列であるdtype )。あなたはすべてのサポートされて見ることができますdtypestf.dtypes.DType

あなたが精通している場合はnumpyの 、テンソルのような(の一種)ですnp.arrays

すべてのテンソルは、Pythonの数値や文字列などの不変です:あなたは、新しいものを作成し、テンソルの内容を更新することはできません。

基本

のは、いくつかの基本的なテンソルを作成してみましょう。

ここでは、「スカラー」や「ランク0」テンソルです。スカラーは単一の値、および無「軸」が含まれています。

 # This will be an int32 tensor by default; see "dtypes" below.
rank_0_tensor = tf.constant(4)
print(rank_0_tensor)
 
tf.Tensor(4, shape=(), dtype=int32)

「ベクター」または「ランク1」テンソルは、値のリストのようなものです。ベクターは1軸を有しています。

 # Let's make this a float tensor.
rank_1_tensor = tf.constant([2.0, 3.0, 4.0])
print(rank_1_tensor)
 
tf.Tensor([2. 3. 4.], shape=(3,), dtype=float32)

「マトリックス」や「ランク2」テンソルは、2軸があります。

 # If we want to be specific, we can set the dtype (see below) at creation time
rank_2_tensor = tf.constant([[1, 2],
                             [3, 4],
                             [5, 6]], dtype=tf.float16)
print(rank_2_tensor)
 
tf.Tensor(
[[1. 2.]
 [3. 4.]
 [5. 6.]], shape=(3, 2), dtype=float16)

スカラー、形状: [] ベクター、形状: [3] 行列、形状: [3, 2]
スカラー、数43つのセクションの行数を含む各。番号を含む各細胞と3×2のグリッド、。

テンソルは、複数の軸を有していてもよく、ここでは3軸を持つテンソルは以下のとおりです。

 # There can be an arbitrary number of
# axes (sometimes called "dimensions")
rank_3_tensor = tf.constant([
  [[0, 1, 2, 3, 4],
   [5, 6, 7, 8, 9]],
  [[10, 11, 12, 13, 14],
   [15, 16, 17, 18, 19]],
  [[20, 21, 22, 23, 24],
   [25, 26, 27, 28, 29]],])
                    
print(rank_3_tensor)
 
tf.Tensor(
[[[ 0  1  2  3  4]
  [ 5  6  7  8  9]]

 [[10 11 12 13 14]
  [15 16 17 18 19]]

 [[20 21 22 23 24]
  [25 26 27 28 29]]], shape=(3, 2, 5), dtype=int32)

あなたは以上の2軸でテンソルを可視化するかもしれない多くの方法があります。

3軸テンソル、形状: [3, 2, 5]

あなたはいずれかを使用してnumpyのアレイにテンソルを変換することができnp.arrayまたはtensor.numpy方法を:

 np.array(rank_2_tensor)
 
array([[1., 2.],
       [3., 4.],
       [5., 6.]], dtype=float16)
 rank_2_tensor.numpy()
 
array([[1., 2.],
       [3., 4.],
       [5., 6.]], dtype=float16)

テンソルは、多くの場合、山車とint型が含まれているが、他の多くの種類を含む、持っています:

  • 複素数
  • ストリング

ベースtf.Tensorクラスが「矩形」にテンソルを要求---すなわち、各軸に沿って、すべての要素が同じ大きさです。しかし、異なる形状を扱うことができるテンソルの専門のタイプがあります。

我々はさらに、要素ごとの乗算、行列の乗算を含むテンソル、上の基本的な数学を行うことができます。

 a = tf.constant([[1, 2],
                 [3, 4]])
b = tf.constant([[1, 1],
                 [1, 1]]) # Could have also said `tf.ones([2,2])`

print(tf.add(a, b), "\n")
print(tf.multiply(a, b), "\n")
print(tf.matmul(a, b), "\n")
 
tf.Tensor(
[[2 3]
 [4 5]], shape=(2, 2), dtype=int32) 

tf.Tensor(
[[1 2]
 [3 4]], shape=(2, 2), dtype=int32) 

tf.Tensor(
[[3 3]
 [7 7]], shape=(2, 2), dtype=int32) 


 print(a + b, "\n") # element-wise addition
print(a * b, "\n") # element-wise multiplication
print(a @ b, "\n") # matrix multiplication
 
tf.Tensor(
[[2 3]
 [4 5]], shape=(2, 2), dtype=int32) 

tf.Tensor(
[[1 2]
 [3 4]], shape=(2, 2), dtype=int32) 

tf.Tensor(
[[3 3]
 [7 7]], shape=(2, 2), dtype=int32) 


テンソルは、操作(OPS)のすべての種類で使用されています。

 c = tf.constant([[4.0, 5.0], [10.0, 1.0]])

# Find the largest value
print(tf.reduce_max(c))
# Find the index of the largest value
print(tf.argmax(c))
# Compute the softmax
print(tf.nn.softmax(c))
 
tf.Tensor(10.0, shape=(), dtype=float32)
tf.Tensor([1 0], shape=(2,), dtype=int64)
tf.Tensor(
[[2.6894143e-01 7.3105860e-01]
 [9.9987662e-01 1.2339458e-04]], shape=(2, 2), dtype=float32)

形状について

テンソルは、形状を有しています。いくつかの語彙:

  • 形状 :テンソルの寸法のそれぞれの長さ(要素の数)。
  • ランク :テンソルの次元数。スカラー行列がランク2であり、ベクトルはランク1を有し、ランク0を有しています。
  • または寸法 :テンソルの特定の次元。
  • サイズ :テンソル内のアイテムの総数、製品形状ベクトル

テンソルとtf.TensorShapeオブジェクトは、これらにアクセスするための便利な性質を持っています:

 rank_4_tensor = tf.zeros([3, 2, 4, 5])
 
階数4のテンソル、形状: [3, 2, 4, 5]
テンソル形状はベクトルのようなものです。4軸テンソル
 print("Type of every element:", rank_4_tensor.dtype)
print("Number of dimensions:", rank_4_tensor.ndim)
print("Shape of tensor:", rank_4_tensor.shape)
print("Elements along axis 0 of tensor:", rank_4_tensor.shape[0])
print("Elements along the last axis of tensor:", rank_4_tensor.shape[-1])
print("Total number of elements (3*2*4*5): ", tf.size(rank_4_tensor).numpy())
 
Type of every element: <dtype: 'float32'>
Number of dimensions: 4
Shape of tensor: (3, 2, 4, 5)
Elements along axis 0 of tensor: 3
Elements along the last axis of tensor: 5
Total number of elements (3*2*4*5):  120

軸は、多くの場合、それぞれのインデックスによって参照されていますが、あなたは常に、各の意味を追跡する必要があります。多くの場合、軸はグローバルからローカルに順序付けされる:バッチは空間次元が続く、第一軸、及び最後に各場所のための機能します。この方法では、特徴ベクトルは、メモリの連続領域です。

典型的な軸順序
各軸が何であるかを追跡します。 4軸テンソルは次のようになります。バッチ、幅、高さ、Freatures

インデキシング

単軸インデックス

TensorFlowは次のように標準のPythonインデックス規則、以下のリストやPythonの文字列のインデックスを作成し、numpyのインデックス作成のための基本的なルールを。

  • インデックスはから始まり0
  • 負のインデックスは末尾から逆方向を数えます
  • コロン、 : 、スライスが使用されstart:stop:step
 rank_1_tensor = tf.constant([0, 1, 1, 2, 3, 5, 8, 13, 21, 34])
print(rank_1_tensor.numpy())
 
[ 0  1  1  2  3  5  8 13 21 34]

スカラーで索引付けすることは次元を削除します。

 print("First:", rank_1_tensor[0].numpy())
print("Second:", rank_1_tensor[1].numpy())
print("Last:", rank_1_tensor[-1].numpy())
 
First: 0
Second: 1
Last: 34

インデックス作成:スライスは次元を保持します。

 print("Everything:", rank_1_tensor[:].numpy())
print("Before 4:", rank_1_tensor[:4].numpy())
print("From 4 to the end:", rank_1_tensor[4:].numpy())
print("From 2, before 7:", rank_1_tensor[2:7].numpy())
print("Every other item:", rank_1_tensor[::2].numpy())
print("Reversed:", rank_1_tensor[::-1].numpy())
 
Everything: [ 0  1  1  2  3  5  8 13 21 34]
Before 4: [0 1 1 2]
From 4 to the end: [ 3  5  8 13 21 34]
From 2, before 7: [1 2 3 5 8]
Every other item: [ 0  1  3  8 21]
Reversed: [34 21 13  8  5  3  2  1  1  0]

多軸のインデックス作成

上位テンソルは、複数のインデックスを渡すことによってインデックス付けされています。

単軸の場合と同様に、単軸まったく同じ規則が独立に各軸に適用されます。

 print(rank_2_tensor.numpy())
 
[[1. 2.]
 [3. 4.]
 [5. 6.]]

各インデックスの整数を渡す結果はスカラーです。

 # Pull out a single value from a 2-rank tensor
print(rank_2_tensor[1, 1].numpy())
 
4.0

あなたは、インデックスの整数とスライスの任意の組み合わせを使用してすることができます:

 # Get row and column tensors
print("Second row:", rank_2_tensor[1, :].numpy())
print("Second column:", rank_2_tensor[:, 1].numpy())
print("Last row:", rank_2_tensor[-1, :].numpy())
print("First item in last column:", rank_2_tensor[0, -1].numpy())
print("Skip the first row:")
print(rank_2_tensor[1:, :].numpy(), "\n")
 
Second row: [3. 4.]
Second column: [2. 4. 6.]
Last row: [5. 6.]
First item in last column: 2.0
Skip the first row:
[[3. 4.]
 [5. 6.]] 


ここで3軸テンソル有する例です。

 print(rank_3_tensor[:, :, 4])
 
tf.Tensor(
[[ 4  9]
 [14 19]
 [24 29]], shape=(3, 2), dtype=int32)

バッチ内の各例では、すべての場所にわたって最後の機能を選択します
インデックス4選択した最後の軸のうちのすべての値を有する3x2x5テンソル。選択された値は、2軸テンソルにパック。

操作シェイプ

テンソルを再成形することは非常に有用です。

tf.reshape基礎となるデータを複製する必要がないため、操作が高速かつ安価です。

 # Shape returns a `TensorShape` object that shows the size on each dimension
var_x = tf.Variable(tf.constant([[1], [2], [3]]))
print(var_x.shape)
 
(3, 1)

 # You can convert this object into a Python list, too
print(var_x.shape.as_list())
 
[3, 1]

あなたは、新しい形状にテンソルの形状を変更することができます。基礎となるデータを複製する必要がないため、再整形は、高速かつ安価です。

 # We can reshape a tensor to a new shape.
# Note that we're passing in a list
reshaped = tf.reshape(var_x, [1, 3])
 
 print(var_x.shape)
print(reshaped.shape)
 
(3, 1)
(1, 3)

同じデータを指して、要求された形状で、データがメモリにそのレイアウトを維持し、新たなテンソルが作成されます。 TensorFlowは、メモリ内の単一のステップに右端のインデックス対応するインクリメントCスタイル「行優先」メモリの順序を使用します。

 print(rank_3_tensor)
 
tf.Tensor(
[[[ 0  1  2  3  4]
  [ 5  6  7  8  9]]

 [[10 11 12 13 14]
  [15 16 17 18 19]]

 [[20 21 22 23 24]
  [25 26 27 28 29]]], shape=(3, 2, 5), dtype=int32)

あなたはテンソルをフラット化した場合、あなたはそれがメモリにレイアウトされたご注文内容を確認することができます。

 # A `-1` passed in the `shape` argument says "Whatever fits".
print(tf.reshape(rank_3_tensor, [-1]))
 
tf.Tensor(
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
 24 25 26 27 28 29], shape=(30,), dtype=int32)

典型的には、唯一の合理的な使用tf.reshape結合または隣接する軸を分割(または追加/削除するためにある1秒)。

スライスが混在していないとして、この3x2x5テンソルの場合は、(3×2)×5または3倍(2×)に再形成、行うには、両方の合理的なものです:

 print(tf.reshape(rank_3_tensor, [3*2, 5]), "\n")
print(tf.reshape(rank_3_tensor, [3, -1]))
 
tf.Tensor(
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]
 [25 26 27 28 29]], shape=(6, 5), dtype=int32) 

tf.Tensor(
[[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]
 [20 21 22 23 24 25 26 27 28 29]], shape=(3, 10), dtype=int32)

いくつかの良い整形。
3x2x5テンソル(3×2)X5に整形同じデータ3倍に作り直さ同じデータ(2×)

同じ要素数を持つ新しい形状のための意志「仕事」を再成形ができますが、軸の順序を尊重していない場合には便利な何もしません。

軸を入れ替えるtf.reshape仕事をしない、あなたは必要がtf.transposeそのため。

 # Bad examples: don't do this

# You can't reorder axes with reshape.
print(tf.reshape(rank_3_tensor, [2, 3, 5]), "\n") 

# This is a mess
print(tf.reshape(rank_3_tensor, [5, 6]), "\n")

# This doesn't work at all
try:
  tf.reshape(rank_3_tensor, [7, -1])
except Exception as e:
  print(f"{type(e).__name__}: {e}")
 
tf.Tensor(
[[[ 0  1  2  3  4]
  [ 5  6  7  8  9]
  [10 11 12 13 14]]

 [[15 16 17 18 19]
  [20 21 22 23 24]
  [25 26 27 28 29]]], shape=(2, 3, 5), dtype=int32) 

tf.Tensor(
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]
 [24 25 26 27 28 29]], shape=(5, 6), dtype=int32) 

InvalidArgumentError: Input to reshape is a tensor with 30 values, but the requested shape requires a multiple of 7 [Op:Reshape]

いくつかの悪い整形。
あなたはリオーダー軸、使用することは、そのためにtf.transposeすることはできません一緒にデータのスライスをミックスしたものは、おそらく間違っています。新しい形状は正確に適合しなければなりません。

あなたはない、完全に指定された形状全体に実行されることがあります。形状が含まれていないのいずれかNone (寸法の長さが不明である)、または形状ではありませんNone (テンソルのランクは不明です)。

除きtf.RaggedTensor 、これが唯一のTensorFlowの、象徴、グラフ、建物のAPIのコンテキストで発生します。

もっと上のDTypes

検査するtf.Tensorのデータ型は使用Tensor.dtypeプロパティを。

作成するときtf.Tensor Pythonオブジェクトから必要に応じてデータ型を指定することもできます。

そうしないと、TensorFlowはあなたのデータを表現できるデータ型を選択します。 TensorFlowはPythonの整数に変換tf.int32に浮動小数点数とPython tf.float32 。さもなければTensorFlowはアレイに変換するときnumpyのが使用するのと同じ規則を使用します。

あなたは、型にタイプからキャストすることができます。

 the_f64_tensor = tf.constant([2.2, 3.3, 4.4], dtype=tf.float64)
the_f16_tensor = tf.cast(the_f64_tensor, dtype=tf.float16)
# Now, let's cast to an uint8 and lose the decimal precision
the_u8_tensor = tf.cast(the_f16_tensor, dtype=tf.uint8)
print(the_u8_tensor)
 
tf.Tensor([2 3 4], shape=(3,), dtype=uint8)

放送

放送から借りた概念であるnumpyので同等の機能 。要するに、一定の条件の下で、小さいテンソルはそれらに組み合わせる操作を実行するときに、より大きなテンソルに合わせて、自動的に「ストレッチ」されています。

あなたはスカラーにテンソルを掛けるか、追加しようとすると単純で最も一般的なケースです。その場合には、スカラーは、他の引数と同じ形状であることが放送されています。

 x = tf.constant([1, 2, 3])

y = tf.constant(2)
z = tf.constant([2, 2, 2])
# All of these are the same computation
print(tf.multiply(x, 2))
print(x * y)
print(x * z)
 
tf.Tensor([2 4 6], shape=(3,), dtype=int32)
tf.Tensor([2 4 6], shape=(3,), dtype=int32)
tf.Tensor([2 4 6], shape=(3,), dtype=int32)

同様に、1サイズの寸法は、他の引数に一致するように伸ばしすることができます。どちらの引数も同じ計算に延伸することができます。

この場合、3×1行列は、要素ごとの1x4行列を乗じたが、3×4の行列を生成することです。 1をリード方法ノートはオプションである:Yの形状である[4]

 # These are the same computations
x = tf.reshape(x,[3,1])
y = tf.range(1, 5)
print(x, "\n")
print(y, "\n")
print(tf.multiply(x, y))
 
tf.Tensor(
[[1]
 [2]
 [3]], shape=(3, 1), dtype=int32) 

tf.Tensor([1 2 3 4], shape=(4,), dtype=int32) 

tf.Tensor(
[[ 1  2  3  4]
 [ 2  4  6  8]
 [ 3  6  9 12]], shape=(3, 4), dtype=int32)

放送追加[3, 1][1, 4]得られる[3,4]
3×4行列で4x1の行列結果を3×1行列を追加

ここでは放送せずに同じ操作は以下のとおりです。

 x_stretch = tf.constant([[1, 1, 1, 1],
                         [2, 2, 2, 2],
                         [3, 3, 3, 3]])

y_stretch = tf.constant([[1, 2, 3, 4],
                         [1, 2, 3, 4],
                         [1, 2, 3, 4]])

print(x_stretch * y_stretch)  # Again, operator overloading
 
tf.Tensor(
[[ 1  2  3  4]
 [ 2  4  6  8]
 [ 3  6  9 12]], shape=(3, 4), dtype=int32)

ブロードキャスト動作はメモリに展開テンソルを具体化することがないように時間の大半は、放送では、時間と空間の両方が効率的です。

あなたは使用してのように見えるの放送内容を確認tf.broadcast_to

 print(tf.broadcast_to(tf.constant([1, 2, 3]), [3, 3]))
 
tf.Tensor(
[[1 2 3]
 [1 2 3]
 [1 2 3]], shape=(3, 3), dtype=int32)

数学的なオペアンプとは異なり、例えば、 broadcast_toメモリを節約するために特別な何もしません。ここでは、テンソルをマテリアライズされています。

それはさらに複雑得ることができます。 このセクションではジェイクVanderPlasの本Pythonのデータ科学ハンドブックのは(numpyの中で再び)トリックを放送より示されています。

tf.convert_to_tensor

以下のようなほとんどのOPS、 tf.matmultf.reshapeクラスのテイク引数tf.Tensor 。ただし、上記の場合には気づくでしょう、私たちはしばしばテンソルのような形のPythonオブジェクトを渡します。

大半は、すべてではありませんが、OPSは呼び出しconvert_to_tensor非テンソル引数のを。そこの変換のレジストリがある、とnumpyののようなほとんどのオブジェクトクラスndarrayTensorShape 、Pythonのリスト、およびtf.Variableすべて自動的に変換されます。

参照tf.register_tensor_conversion_function詳細については、あなたがあなた自身のタイプを持っている場合は、自動的にテンソルに変換したいと思います。

ラグドテンソル

いくつかの軸に沿った要素の変数番号を持つテンソルは「ギザギザ」と呼ばれています。使用tf.ragged.RaggedTensor不揃いデータ用。

例えば、これは、通常のテンソルとして表現することはできません。

tf.RaggedTensor 、形状: [4, None]
2軸は、各行が異なる長さを有することができ、テンソルを不規則。
 ragged_list = [
    [0, 1, 2, 3],
    [4, 5],
    [6, 7, 8],
    [9]]
 
 try:
  tensor = tf.constant(ragged_list)
except Exception as e:
  print(f"{type(e).__name__}: {e}")
 
ValueError: Can't convert non-rectangular Python sequence to Tensor.

代わりに作成tf.RaggedTensor使用してtf.ragged.constant

 ragged_tensor = tf.ragged.constant(ragged_list)
print(ragged_tensor)
 
<tf.RaggedTensor [[0, 1, 2, 3], [4, 5], [6, 7, 8], [9]]>

形状tf.RaggedTensor 、未知の寸法が含まれています。

 print(ragged_tensor.shape)
 
(4, None)

文字列のテンソル

tf.stringあるdtype我々はテンソルの文字列(可変長バイト配列)としてデータを表すことができると言うことです。

文字列は原子であり、Pythonの文字列がある方法でインデックスを作成することはできません。文字列の長さは、テンソルの大きさのものではありません。参照tf.stringsそれらを操作するための機能のために。

ここでは、スカラ文字列テンソルは以下のとおりです。

 # Tensors can be strings, too here is a scalar string.
scalar_string_tensor = tf.constant("Gray wolf")
print(scalar_string_tensor)
 
tf.Tensor(b'Gray wolf', shape=(), dtype=string)

そして、文字列のベクトル:

文字列のベクトル、形状: [3,]
文字列の長さはテンソルの軸の一つではありません。
 # If we have three string tensors of different lengths, this is OK.
tensor_of_strings = tf.constant(["Gray wolf",
                                 "Quick brown fox",
                                 "Lazy dog"])
# Note that the shape is (3,). The string length is not included.
print(tensor_of_strings)
 
tf.Tensor([b'Gray wolf' b'Quick brown fox' b'Lazy dog'], shape=(3,), dtype=string)

上記のプリントアウトではbプレフィックスがあることを示しtf.string DTYPEは、Unicode文字列が、バイト文字列ではありません。参照してください。 Unicodeのチュートリアルを TensorFlowでのUnicodeテキストの操作の詳細のために。

あなたがUnicode文字を渡すと、彼らは、UTF-8でエンコードされています。

 tf.constant("🥳👍")
 
<tf.Tensor: shape=(), dtype=string, numpy=b'\xf0\x9f\xa5\xb3\xf0\x9f\x91\x8d'>

文字列を含むいくつかの基本的な機能はで見つけることができtf.strings含め、 tf.strings.split

 # We can use split to split a string into a set of tensors
print(tf.strings.split(scalar_string_tensor, sep=" "))
 
tf.Tensor([b'Gray' b'wolf'], shape=(2,), dtype=string)

 # ...but it turns into a `RaggedTensor` if we split up a tensor of strings,
# as each string might be split into a different number of parts.
print(tf.strings.split(tensor_of_strings))
 
<tf.RaggedTensor [[b'Gray', b'wolf'], [b'Quick', b'brown', b'fox'], [b'Lazy', b'dog']]>

3つの文字列の分割、形状: [3, None]
分割複数の文字列を返すtf.RaggedTensor

そしてtf.string.to_number

 text = tf.constant("1 10 100")
print(tf.strings.to_number(tf.strings.split(text, " ")))
 
tf.Tensor([  1.  10. 100.], shape=(3,), dtype=float32)

あなたが使用することはできませんがtf.cast数値に文字列テンソルを回すために、あなたはバイトに変換して、数字にすることができます。

 byte_strings = tf.strings.bytes_split(tf.constant("Duck"))
byte_ints = tf.io.decode_raw(tf.constant("Duck"), tf.uint8)
print("Byte strings:", byte_strings)
print("Bytes:", byte_ints)
 
Byte strings: tf.Tensor([b'D' b'u' b'c' b'k'], shape=(4,), dtype=string)
Bytes: tf.Tensor([ 68 117  99 107], shape=(4,), dtype=uint8)

 # Or split it up as unicode and then decode it
unicode_bytes = tf.constant("アヒル 🦆")
unicode_char_bytes = tf.strings.unicode_split(unicode_bytes, "UTF-8")
unicode_values = tf.strings.unicode_decode(unicode_bytes, "UTF-8")

print("\nUnicode bytes:", unicode_bytes)
print("\nUnicode chars:", unicode_char_bytes)
print("\nUnicode values:", unicode_values)
 

Unicode bytes: tf.Tensor(b'\xe3\x82\xa2\xe3\x83\x92\xe3\x83\xab \xf0\x9f\xa6\x86', shape=(), dtype=string)

Unicode chars: tf.Tensor([b'\xe3\x82\xa2' b'\xe3\x83\x92' b'\xe3\x83\xab' b' ' b'\xf0\x9f\xa6\x86'], shape=(5,), dtype=string)

Unicode values: tf.Tensor([ 12450  12498  12523     32 129414], shape=(5,), dtype=int32)

tf.string DTYPEはTensorFlow内のすべての生のバイトのデータ用に使用されています。 tf.ioモジュールは、画像を復号化し、CSVを解析含むバイト、およびからのデータを変換するための関数を含んでいます。

スパーステンソル

時には、あなたのデータは非常に広いスペース埋め込むように、まばらです。 TensorFlowはサポートtf.sparse.SparseTensorおよび関連業務が効率的にまばらなデータを格納します。

A tf.SparseTensor 、形状: [3, 4]
唯一の2つのセルの中の値を持つ3x4のグリッド、。
 # Sparse tensors store values by index in a memory-efficient manner
sparse_tensor = tf.sparse.SparseTensor(indices=[[0, 0], [1, 2]],
                                       values=[1, 2],
                                       dense_shape=[3, 4])
print(sparse_tensor, "\n")

# We can convert sparse tensors to dense
print(tf.sparse.to_dense(sparse_tensor))
 
SparseTensor(indices=tf.Tensor(
[[0 0]
 [1 2]], shape=(2, 2), dtype=int64), values=tf.Tensor([1 2], shape=(2,), dtype=int32), dense_shape=tf.Tensor([3 4], shape=(2,), dtype=int64)) 

tf.Tensor(
[[1 0 0 0]
 [0 0 2 0]
 [0 0 0 0]], shape=(3, 4), dtype=int32)