14_5:演算

TensorFlow.jsではテンソル上で実行できる演算が提供されています。これらの演算は、そのテンソルの値を変えるのではなく、新しいテンソルを返します。

算術演算

– tf.add (a, b), tf.sub (a, b), tf.mul (a, b), tf.div (a, b)
– tf.mod (a, b)
– tf.pow (base, exp)

const x1 = tf.tensor2d([[1, 1], [1, 1]]);
const y11 = tf.tensor2d([[2, 2], [2, 2]]);
const y12 = tf.scalar(5);

tf.add(x1, y11).print();
x1.add(y11).print();
/*
Tensor
    [[3, 3],
     [3, 3]]
*/

tf.add(x1, y12).print();
x1.add(y12).print();
/*
Tensor
    [[6, 6],
     [6, 6]]
*/

– tf.maximum (a, b), tf.minimum (a, b)

const x2 = tf.tensor1d([2, 4, 3]);
const y21 = tf.tensor1d([1, 2, 9]);
const y22 = tf.scalar(3);

tf.maximum(x2, y21).print();
x2.maximum(y21).print();
/*
Tensor
    [2, 4, 9]
*/

tf.maximum(x2, y22).print();
x2.maximum(y22).print();
/*
Tensor
    [3, 4, 3]
*/

– tf.squaredDifference (a, b): 要素ごとの(a – b) * (a – b)を返す。

const x3 = tf.tensor1d([2, 4, 3]);
const y31 = tf.tensor1d([1, 2, 9]);
const y32 = tf.scalar(2);

tf.squaredDifference(x3, y31).print();
x3.squaredDifference(y31).print();
/*
Tensor
    [1, 4, 36]
*/

tf.squaredDifference(x3, y32).print();
x3.squaredDifference(y32).print();
/*
Tensor
    [0, 4, 1]
*/

数学演算

– tf.reciprocal (x)
– tf.square (x)
– tf.sqrt (x)
– tf.rsqrt (x): 平方根の逆数
– tf.exp (x)
– tf.log (x)

const x4 = tf.tensor2d([[-1, 2], [-3, 4]]);

tf.square(x4).print();
x4.square().print();
/*
Tensor
    [[1, 4 ],
     [9, 16]]
*/

tf.sqrt(x4).print();
x4.sqrt().print();
/*
Tensor
    [[NaN, 1.4142135],
     [NaN, 2        ]]
*/

– tf.abs (x)
– tf.sign (x)
– tf.neg (x): (-1 * x)
– tf.round (x)
– tf.floor (x)
– tf.ceil (x)

const x5 = tf.tensor1d([-1, 2, -3]);

tf.abs(x5)
x5.abs().print();
/*
Tensor
    [1, 2, 3]
*/

– tf.sigmoid, tf.logSigmoid
– tf.elu (exponential linear), tf.selu (x) (scaled exponential linear)
– tf.relu (x), tf.leakyRelu (x, alpha?), tf.prelu (x, alpha) (leaky rectified linear)
– tf.erf (ガウス誤差関数)

const x6 = tf.tensor1d([-1, 2, -3, 4]);

tf.relu(x6).print();
x6.relu().print();
/*
Tensor
    [0, 2, 0, 4]
*/

– tf.cos, tf.acos, tf.cosh, tf.acosh
– tf.sin, tf.asin, tf.sinh, tf.asinh
– tf.tan, tf.atan, tf.tanh, tf.atanh

行列演算

tf.matMul

tf.matMul (a, b, transposeA?, transposeB?): 2つの行列のドット積(A * B)
If transposeパラメータがtrueの場合、行列は乗算前に転置される。

const x7 = tf.tensor2d([1, 2], [1, 2]);
/*
Tensor
     [[1, 2],]
*/
const y7 = tf.tensor2d([1, 2, 3, 4], [2, 2]);
/*
Tensor
    [[1, 2],
     [3, 4]]
*/

tf.matMul(x7, y7).print();
x7.matMul(y7).print();
/*
Tensor
     [[7, 10],]
*/
tf.outerProduct

tf.outerProduct (v1, v2)

const x8 = tf.tensor1d([1, 2, 3]);
const y8 = tf.tensor1d([1, 2, 3]);

tf.outerProduct(x8, y8).print();
/*
Tensor
    [[1, 2, 3],
     [2, 4, 6],
     [3, 6, 9]]
*/
tf.transpose

tf.transpose (x, perm?): 次元をpermに準じて置き換える。
返されるtf.Tensorの次元iは、入力の次元perm[i]に一致する。permが与えられない場合は、[n-1…0]に設定される(nは入力tf.Tensorのランク)。

例:入力tf.Tensorのシェイプが[1,3,4]の場合、
+ permが与えられない: perm=[2,1,0] => シェイプが[4,3,1]のtf.Tensorが返される。
+ perm=[0,2,1] => シェイプが[1,4,3]のtf.Tensorが返される。
+ perm=[1,2,0] => シェイプが[3,4,1]のtf.Tensorが返される。


const x9 = tf.tensor3d([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], [1, 3, 4]);
x9.print(true);
/*
Tensor
  rank: 3
  shape: [1,3,4]
  values:
    [[[1, 2 , 3 , 4 ],
      [5, 6 , 7 , 8 ],
      [9, 10, 11, 12]]]
*/

x9.transpose().print(true);  // or tf.transpose(x9)
/*
Tensor
  rank: 3
  shape: [4,3,1]
  values:
    [[[1 ],
      [5 ],
      [9 ]],

     [[2 ],
      [6 ],
      [10]],

     [[3 ],
      [7 ],
      [11]],

     [[4 ],
      [8 ],
      [12]]]
*/

x9.transpose([0, 2, 1]).print(true);
/*
Tensor
  rank: 3
  shape: [1,4,3]
  values:
    [[[1, 5, 9 ],
      [2, 6, 10],
      [3, 7, 11],
      [4, 8, 12]]]
*/

x9.transpose([1, 2, 0]).print(true);
/*
Tensor
  rank: 3
  shape: [3,4,1]
  values:
    [[[1 ],
      [2 ],
      [3 ],
      [4 ]],

     [[5 ],
      [6 ],
      [7 ],
      [8 ]],

     [[9 ],
      [10],
      [11],
      [12]]]
*/
tf.norm

tf.norm (x, ord?, axis?, keepDims?): さまざまな異なるベクトルのノルム(1-norm、ユークリッドノルムつまり2-norm、無限大ノルム、p > 0でのp-norm)や行列ノルム(フロベニウスノルム、1-norm、無限大ノルム)を計算する。

ord ノルム(行列) ノルム(ベクトル)
‘euclidean’ フロベニウスノルム 2-norm
‘fro’ フロベニウスノルム
Infinity max(sum(abs(x), axis=1)) max(abs(x))
-Infinity min(sum(abs(x), axis=1)) min(abs(x))
1 max(sum(abs(x), axis=0)) sum(abs(x))
2 sum(abs(x)^2)^1/2

axis (number|number[]):
+ axisがnull(デフォルト)の場合:入力はベクトルと見なされ、ノルムはtf.Tensorの値のセット全体で計算される。
+ axisが整数の場合:入力はベクトルのまとまりと見なされ、axisがベクトルノルムを計算するxの軸を決める
+ axisが整数の2-tupleの場合([a,b]というペア):入力は行列のまとまりと見なされ、axisが行列ノルムを計算するNDArrayの軸を決める。

keepDims (boolean): trueの場合、ノルムは入力と同じ次元を持つ。

サンプル1:


// (-3)^2 + 4^2 = 5^2
const x = tf.tensor1d([-3, 4]);

x.norm().print();
/*
Tensor
    5
*/

x.norm(2).print();
/*
Tensor
    5
*/

x.norm(1).print();
/*
Tensor
    7
*/

x.norm('euclidean').print();
/*
Tensor
    5
*/

x.norm(Infinity).print();
/*
Tensor
    4
*/

x.norm(-Infinity).print();
/*
Tensor
    3
*/

サンプル2:

// (-3)^2 + 4^2 = 5^2
// (-5)^2 + 12^2 = 13^2
const y = tf.tensor2d([[-3, 4], [-5, 12]]);

y.norm().print();
/*
Tensor
    13.928388595581055
*/

y.norm(2).print();
/*
Tensor
    13.928388595581055
*/

y.norm(1).print();
/*
Tensor
    24
*/

y.norm('euclidean').print();
/*
Tensor
    13.928388595581055
*/

y.norm(Infinity).print();
/*
Tensor
    12
*/

y.norm(-Infinity).print();
/*
Tensor
    3
*/

サンプル3:


// (-3)^2 + 4^2 = 5^2
// (-5)^2 + 12^2 = 13^2
const y = tf.tensor2d([[-3, 4], [-5, 12]]);

y.norm(2, 0).print();
/*
Tensor
    [5.8309517, 12.6491117]
*/

y.norm(2, 1).print();
/*
Tensor
    [5, 13]
*/

y.norm(1, 0).print();
/*
Tensor
    [8, 16]
*/

y.norm(1, 1).print();
/*
Tensor
    [7, 17]
*/

y.norm(Infinity, 0).print();
/*
Tensor
    [5, 12]
*/

y.norm(Infinity, 1).print();
/*
Tensor
    [4, 12]
*/

y.norm(Infinity, [0, 1]).print();
/*
Tensor
    17
*/

y.norm(-Infinity, 0).print();
/*
Tensor
    [3, 4]
*/

y.norm(-Infinity, 1).print();
/*
Tensor
    [3, 5]
*/

y.norm(-Infinity, [0, 1]).print();
/*
Tensor
    7
*/
論理演算

– tf.equal (a, b)
– tf.greater (a, b)
– tf.greaterEqual (a, b)
– tf.less (a, b)
– tf.lessEqual (a, b)

const a1 = tf.tensor1d([1, 3, 5]);
const b11 = tf.tensor1d([1, 2, 3]);
const b12 = tf.scalar(4);

tf.greater(a1, b11).print();
a1.greater(b11).print();
/*
Tensor
    [0, 1, 1]
*/

tf.greater(a1, b12).print();
a1.greater(b12).print();
/*
Tensor
    [0, 0, 1]
*/

– tf.logicalAnd (a, b)
– tf.logicalNot (a, b)
– tf.logicalOr (a, b)
– tf.logicalXor (a, b)

const a2 = tf.tensor1d([1, 1, 0, 0], 'bool');
const b2 = tf.tensor1d([1, 0, 1, 0], 'bool');

tf.logicalAnd(a2, b2).print();
a2.logicalAnd(b2).print();
/*
Tensor
    [1, 0, 0, 0]
*/

– tf.where (condition, a, b): conditionがtrueの場合はaから、falseの場合はbから選ばれた要素から成るtf.Tensorを返す。

const a3 = tf.tensor1d([1, 3, 5, 7]);
const b3 = tf.tensor1d([2, 3, 4, 9]);

tf.where(tf.greater(a3, b3), a3, b3).print();
/*
Tensor
    [2, 3, 5, 9]
*/

const a4 = tf.tensor1d([1, 3, 5, 7]);
const b4 = tf.scalar(4);
const alt = tf.fill([4], 9999);
/*
Tensor
    [9999, 9999, 9999, 9999]
*/

tf.where(tf.less(a4, b4), a4, alt).print();
/*
Tensor
    [1, 3, 9999, 9999]
*/

コメントを残す

メールアドレスが公開されることはありません。 * が付いている欄は必須項目です

CAPTCHA