tf.print(tf.argmin(a))

8
0

#tf.math.top_k可以用于对张量排序
a = tf.constant([1,3,7,5,4,8])

values,indices = tf.math.top_k(a,3,sorted=True)
tf.print(values)
tf.print(indices)

#利用tf.math.top_k можно в TensorFlow реализовать алгоритм KNN

[8 7 5]
[5 2 3]

# Умножение матриц
a = tf.constant([[1,2],[3,4]])
b = tf.constant([[2,0],[0,2]])
a@b  # Эквивалентно tf.matmul(a,b)

<tf.Tensor: shape=(2, 2), dtype=int32, numpy=
array([[2, 4],
       [6, 8]], dtype=int32)>

# Транспонирование матрицы
a = tf.constant([[1,2],[3,4]])
tf.transpose(a)

<tf.Tensor: shape=(2, 2), dtype=int32, numpy=
array([[1, 3],
       [2, 4]], dtype=int32)>

# Вычисление обратной матрицы, должно быть типа tf.float32 или tf.double
a = tf.constant([[1.0,2],[3,4]],dtype = tf.float32)
tf.linalg.inv(a)

<tf.Tensor: shape=(2, 2), dtype=float32, numpy=
array([[-2.0000002 ,  1.0000001 ],
       [ 1.5000001 , -0.50000006]], dtype=float32)>

# Вычисление следа матрицы
a = tf.constant([[1.0,2],[3,4]],dtype = tf.float32)
tf.linalg.trace(a)

<tf.Tensor: shape=(), dtype=float32, numpy=5.0>

# Вычисление нормы матрицы
a = tf.constant([[1.0,2],[3,4]])
tf.linalg.norm(a)

<tf.Tensor: shape=(), dtype=float32, numpy=5.477226>

# Вычисление определителя матрицы
a = tf.constant([[1.0,2],[3,4]])
tf.linalg.det(a)

<tf.Tensor: shape=(), dtype=float32, numpy=-2.0>

# Вычисление собственных значений матрицы
a = tf.constant([[1.0,2],[-5,4]])
tf.linalg.eigvals(a)

<tf.Tensor: shape=(2,), dtype=complex64, numpy=array([2.4999995+2.7838817j, 2.5      -2.783882j ], dtype=complex64)>

# QR-разложение матрицы, матрица a разлагается на ортогональную матрицу q и верхнюю треугольную матрицу r
# QR-разложение фактически выполняет Schmidt orthogonalization для матрицы a

a = tf.constant([[1.0,2.0],[3.0,4.0]],dtype = tf.float32)
q,r = tf.linalg.qr(a)
tf.print(q)
tf.print(r)
tf.print(q@r)

[[-0.316227794 -0.948683321]
 [-0.948683321 0.316227734]]
[[-3.1622777 -4.4271884]
 [0 -0.632455349]]
[[1.00000012 1.99999976]
 [3 4]]

# SVD-разложение матрицы
# SVD-разложение может разложить любую матрицу на ортогональную матрицу u, диагональную матрицу s и транспонированную ортогональную матрицу v.t()
# SVD часто используется для сжатия матриц и уменьшения размерности

a  = tf.constant([[1.0,2.0],[3.0,4.0],[5.0,6.0]], dtype = tf.float32)
s,u,v = tf.linalg.svd(a)
tf.print(u,"\n")
tf.print(s,"\n")
tf.print(v,"\n")
tf.print(u@tf.linalg.diag(s)@tf.transpose(v))

# Используя SVD-разложение, можно реализовать анализ главных компонент и уменьшение размерности в TensorFlow

[[0.229847744 -0.88346082]
 [0.524744868 -0.240782902]
 [0.819642067 0.401896209]] 

[9.52551842 0.51429987] 

[[0.619629562 0.784894466]
 [0.784894466 -0.619629562]] 

[[1.00000119 2]
 [3.00000095 4.00000048]
 [5.00000143 6.00000095]]

a = tf.constant([1,2,3])
b = tf.constant([[0,0,0],[1,1,1],[2,2,2]])
b + a  # Эквивалентно b + tf.broadcast_to(a,b.shape)

<tf.Tensor: shape=(3, 3), dtype=int32, numpy=
array([[1, 2, 3],
       [2, 3, 4],
       [3, 4, 5]], dtype=int32)>

tf.broadcast_to(a,b.shape)

<tf.Tensor: shape=(3, 3), dtype=int32, numpy=
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]], dtype=int32)>

# Вычислить форму результата после вещания, статическая форма, параметр типа TensorShape
tf.broadcast_static_shape(a.shape,b.shape)

TensorShape([3, 3])

# Вычислить форму результата после вещания, динамическая форма, параметры типа Tensor
c = tf.constant([1,2,3])
d = tf.constant([[1],[2],[3]])
tf.broadcast_dynamic_shape(tf.shape(c),tf.shape(d))

<tf.Tensor: shape=(2,), dtype=int32, numpy=array([3, 3], dtype=int32)>

# Эффект вещания
c+d # Эквивалентно tf.broadcast_to(c,[3,3]) + tf.broadcast_to(d,[3,3])

<tf.Tensor: shape=(3, 3), dtype=int32, numpy=
array([[2, 3, 4],
       [3, 4, 5],
       [4, 5, 6]], dtype=int32)>