TensorFlow используется во множестве приложений, от распознавания изображений и речи до обработки естественного языка и робототехники.

Tensorflow — это библиотека, которая помогает инженерам создавать и обучать модели глубокого обучения. Он предоставляет все инструменты, необходимые для создания нейронных сетей.

Мы можем использовать тензорный поток для обучения нейронных сетей от простых до сложных, используя большие наборы данных.

Tensorflow используется во множестве приложений, от распознавания изображений и речи до обработки естественного языка и робототехники. TensorFlow позволяет нам быстро и легко создавать мощные модели ИИ с высокой точностью и производительностью.

Tensorflow также работает с GPU и TPU, которые являются типами компьютерных чипов, созданных для расширения возможностей TensorFlow. Эти чипы ускоряют работу Tensorflow, что полезно, когда у вас есть много данных для работы.

В этой статье мы узнаем о тензорах и о том, как работать с тензорами с помощью TensorFlow. Давайте погрузимся прямо в.

Что такое тензор?

Простое объяснение состоит в том, что тензор — это многомерный массив.

Скаляр - это одно число. Вектор — это массив чисел. Матрица представляет собой двумерный массив. Тензор — это n-мерный массив.

В Tensorflow все можно считать тензором, включая скаляр. Скаляром будет тензор размерности 0, вектор размерности 1 и матрица размерности 2.

Теперь это полезно, потому что мы не ограничены работой со сложными наборами данных в Tensorflow. Tensorflow может обрабатывать данные любого типа и передавать их в модели машинного обучения.

Что такое Тензорфлоу?

TensorFlow — это программная библиотека с открытым исходным кодом для построения нейронных сетей. Команда Google Brain создала ее, и сегодня это самая популярная библиотека глубокого обучения на рынке.

Вы можете использовать тензорный поток для создания моделей ИИ, включая распознавание изображений и речи, обработку естественного языка и прогнозное моделирование.

TensorFlow использует граф потока данных для представления вычислений. Проще говоря, Tensorlfow упростил создание сложных моделей машинного обучения.

Tensorflow выполняет много работы за кулисами, что делает его полезным при создании и обучении любой модели машинного обучения. TensorFlow также управляет вычислениями, включая распараллеливание и оптимизацию, от имени пользователя.

Тензорфлоу и Керас

TensorFlow имеет высокоуровневый API, который называется Keras. Keras был отдельным проектом, который теперь доступен в библиотеке TensorFlow. Keras упрощает определение и обучение моделей, а Tensorflow обеспечивает больший контроль над вычислениями.

TensorFlow поддерживает широкий спектр оборудования, включая процессоры, графические процессоры и TPU. TPU — это блоки обработки тензоров, созданные специально для работы с тензорами и Tensorflow.

Мы также можем запускать TensorFlow на мобильных устройствах и устройствах IoT, используя Tensorflow Lite. TensorFlow также имеет большое сообщество разработчиков и обновляется новыми функциями и возможностями.

Построение тензоров с помощью Tensorflow

Давайте начнем писать код. Если у вас не установлен tensorflow, вы можете использовать блокнот Google Colab, чтобы следовать инструкциям.

Начнем с импорта tensorflow и распечатки версии.

import tensorflow as tf
print(tf.__version__)
OUTPUT:
2.9.2

Давайте сначала создадим скаляр, используя tf.constant. Мы используем tf.constant для создания нового постоянного значения. Мы также можем использовать tf.variable для создания значения переменной. Затем мы напечатаем значение, а также проверим размерность скаляра, используя свойство ndim. Его размерность будет равна нулю, потому что это единственное значение.

scalar = tf.constant(7)
print(scalar)
print(scalar.ndim)
OUTPUT:
tf.Tensor(7, shape=(), dtype=int32)
0

Теперь давайте создадим вектор и напечатаем его размеры. Вы можете видеть, что размер равен 1.

vector = tf.constant([10,10])
print(vector)
print(vector.ndim)
OUTPUT:
tf.Tensor([10 10], shape=(2,), dtype=int32)
1

Теперь давайте попробуем создать матрицу и распечатать ее размеры.

matrix = tf.constant([
    [10,11],
    [12,13]
])
print(matrix)
print(matrix.ndim)
OUTPUT:

tf.Tensor(
[[10 11]
 [12 13]], shape=(2, 2), dtype=int32)
2

Вы увидите, что размер теперь равен 2. Вы также можете видеть, что форма матрицы 2 на 2.

Формы и размеры полезны при работе с тензорным потоком, потому что мы будем часто менять их, используя эти данные для обучения нейронных сетей.

Мы видели, что эти тензоры имеют тип данных по умолчанию int32. Что, если мы хотим создать набор данных с пользовательским типом данных?

tf.constant предоставляет нам аргумент dtype. Давайте снова создадим ту же матрицу с float16 в качестве типа данных.

tensor_1 = tf.constant([
    [
        [1,2,3]
    ],
    [
        [4,5,6]
    ],
    [
        [7,8,9]
    ]
],dtype='float32')
print(tensor_1)
OUTPUT:

tf.Tensor(
[[[1. 2. 3.]]

 [[4. 5. 6.]]

 [[7. 8. 9.]]], shape=(3, 1, 3), dtype=float32)

Теперь давайте создадим тензор. Мы введем трехмерный массив в tf.constant. Мы также напечатаем его размеры.

tensor = tf.constant([
    [
        [1,2,3]
    ],
    [
        [4,5,6]
    ],
    [
        [7,8,9]
    ]
])
print(tensor)
print(tensor.ndim)
OUTPUT:
tf.Tensor(
[[[1 2 3]]
 [[4 5 6]]
 [[7 8 9]]], shape=(3, 1, 3), dtype=int32)
3

Теперь у нас есть тензор размерности 3 и форма 3 на 1 на 3. Это самый простой тензор, который вы можете создать. В реальных сценариях мы будем иметь дело с тензорами более высоких измерений и более крупных форм.

Теперь давайте посмотрим, как создать переменный тензор. Мы не будем использовать переменные тензоры очень часто по сравнению с постоянными тензорами, но хорошо знать, что у нас есть возможность.

Мы будем использовать tf.Variable для создания переменного тензора. Разница между постоянным тензором и переменным тензором заключается в том, что вы можете изменить данные в переменном тензоре, но вы не можете изменить значения в постоянном тензоре. Давайте создадим переменный тензор и напечатаем размеры.

var_tensor = tf.Variable([
    [
        [1,2,3]
    ],
    [
        [4,5,6]
    ],
    [
        [7,8,9]
    ]
])
print(var_tensor)
OUTPUT:
<tf.Variable 'Variable:0' shape=(3, 1, 3) dtype=int32, numpy=
array([[[1, 2, 3]],
       [[4, 5, 6]],
       [[7, 8, 9]]], dtype=int32)>

Генерация и загрузка тензоров

Давайте посмотрим, как генерировать тензоры. В большинстве случаев вы не будете создавать тензоры с нуля. Вы либо загрузите набор данных, либо преобразуете другие наборы данных, такие как массивы NumPy, в тензоры, либо сгенерируете тензоры. Во-первых, давайте посмотрим, как генерировать тензоры.

Давайте создадим тензор со случайными значениями. Это можно сделать двумя распространенными способами: сгенерировать нормальное распределение данных или равномерное распределение данных.

Нормальное распределение представляет собой колоколообразную кривую, представляющую распределение данных. Большая часть данных будет близка к среднему значению, и меньшее количество данных будет отличаться от среднего. Это означает, что вероятность получить значение, близкое к среднему, выше.

Равномерное распределение — это прямая линия, представляющая распределение данных. Все значения в равномерном распределении будут иметь равную вероятность появления в заданном диапазоне.

Прежде чем мы будем генерировать случайные значения, вы должны понять, что такое начальное число. Если мы используем начальное значение, мы можем регенерировать один и тот же набор данных несколько раз. Это будет полезно, когда мы хотим протестировать нашу модель машинного обучения на тех же данных после настройки ее производительности.

Создадим два массива случайных тензоров. Сначала мы установим начальное число и сгенерируем случайные значения, используя это начальное число.

seed = tf.random.Generator.from_seed(42)

Теперь мы создадим нормальное и равномерное распределение в форме 3 на 2.

normal_tensor = seed.normal(shape=(3,2))
print(normal_tensor)
uniform_tensor = seed.uniform(shape=(3,2))
print(uniform_tensor)
OUTPUT:
tf.Tensor( [[-0.7565803  -0.06854702]  [ 0.07595026 -1.2573844 ]  [-0.23193765 -1.8107855 ]], shape=(3, 2), dtype=float32)
tf.Tensor( [[0.7647915  0.03845465]  [0.8506975  0.20781887]  [0.711869   0.8843919 ]], shape=(3, 2), dtype=float32)

У нас есть два созданных тензора, один с нормальным распределением случайных чисел, а другой с равномерным распределением случайных чисел.

Далее мы создадим тензор с нулями и единицами. В TensorFlow тензоры, заполненные нулями или единицами, часто используются в качестве отправной точки для создания других тензоров. Они также могут быть заполнителями для входных данных в вычислительном графе.

Чтобы создать тензор нулей, используйте функцию tf.zeros с фигурой в качестве входного параметра. Чтобы создать тензор с единицами, мы используем tf.ones с формой в качестве входного аргумента.

zeros = tf.zeros(shape=(3,2))
print(zeros)
ones = tf.ones(shape=(3,2))
print(ones)
OUTPUT:
tf.Tensor(
[[0. 0.]
 [0. 0.]
 [0. 0.]], shape=(3, 2), dtype=float32)
tf.Tensor(
[[1. 1.]
 [1. 1.]
 [1. 1.]], shape=(3, 2), dtype=float32)

Теперь давайте посмотрим на преобразование массивов NumPy в тензоры. Если вы не знаете, что такое NumPy, это библиотека Python для численных вычислений. Это помогает нам обрабатывать большие наборы данных и выполнять с ними различные вычисления.

Давайте импортируем NumPy и создадим массив NumPy, используя функцию упорядочения Numpy.

import numpy as np
numpy_arr = np.arange(1,25,dtype=np.int32)

Теперь мы можем создать тензор, используя функцию tf.constant с массивом NumPy в качестве входных данных. Tensorflow имеет встроенную поддержку для обработки массивов NumPy, так что это просто вопрос импорта массива NumPy и установки формы.

print(numpy_arr)
numpy_tensor = tf.constant(numpy_arr,shape=[2,4,3])
print(numpy_tensor)
OUTPUT:
[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24]
tf.Tensor(
[[[ 1  2  3]
  [ 4  5  6]
  [ 7  8  9]
  [10 11 12]]
 [[13 14 15]
  [16 17 18]
  [19 20 21]
  [22 23 24]]], shape=(2, 4, 3), dtype=int32)

Вы можете видеть как массив numpy, так и наш тензор. Исходный массив numpy был 1x12, но наш тензор 2x4x3. Это называется изменением формы тензора, которое мы часто делаем при обучении глубоких нейронных сетей.

Основные операции с использованием Tensorflow

Мы узнали, как создаются тензоры в TensorFlow. Теперь давайте рассмотрим некоторые основные операции с использованием тензоров.

Мы начнем с получения некоторой информации о наших тензорах. Давайте создадим четырехмерный тензор с нулевыми значениями формы 2x3x4x5.

rank4_tensor = tf.zeros([2,3,4,5])
print(rank4_tensor)
OUTPUT:
tf.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. 0.]
   [0. 0. 0. 0. 0.]
   [0. 0. 0. 0. 0.]
   [0. 0. 0. 0. 0.]]
  [[0. 0. 0. 0. 0.]
   [0. 0. 0. 0. 0.]
   [0. 0. 0. 0. 0.]
   [0. 0. 0. 0. 0.]]]

 [[[0. 0. 0. 0. 0.]
   [0. 0. 0. 0. 0.]
   [0. 0. 0. 0. 0.]
   [0. 0. 0. 0. 0.]]
  [[0. 0. 0. 0. 0.]
   [0. 0. 0. 0. 0.]
   [0. 0. 0. 0. 0.]
   [0. 0. 0. 0. 0.]]
  [[0. 0. 0. 0. 0.]
   [0. 0. 0. 0. 0.]
   [0. 0. 0. 0. 0.]
   [0. 0. 0. 0. 0.]]]], shape=(2, 3, 4, 5), dtype=float32)

Мы создали наш тензор ранга 4. Теперь давайте получим некоторую информацию о размере, форме (количестве значений) и размерности тензора. Мы будем использовать функцию tf.size, чтобы получить размер. Свойства shape и ndim дадут нам форму и размеры тензора.

print("Size",tf.size(rank4_tensor))
print("shape",rank4_tensor.shape)
print("Dimension",rank4_tensor.ndim)
OUTPUT: 

Size tf.Tensor(120, shape=(), dtype=int32)
shape (2, 3, 4, 5)
Dimension 4

Давайте посмотрим на некоторые простые вычисления с использованием тензора. Я создам новый базовый тензор.

basic_tensor = tf.constant([[10,11],[12,13]])
print(basic_tensor)
OUTPUT: 

tf.Tensor(
[[10 11]
 [12 13]], shape=(2, 2), dtype=int32)

Попробуем выполнить несколько простых операций. Мы можем складывать, вычитать, умножать и делить каждое значение в тензоре, используя основные операторы.

print(basic_tensor + 10)
print(basic_tensor - 10)
print(basic_tensor * 10)
print(basic_tensor / 10)
OUTPUT:
tf.Tensor(
[[20 21]
 [22 23]], shape=(2, 2), dtype=int32)
tf.Tensor(
[[0 1]
 [2 3]], shape=(2, 2), dtype=int32)
tf.Tensor(
[[100 110]
 [120 130]], shape=(2, 2), dtype=int32)
tf.Tensor(
[[1.  1.1]
 [1.2 1.3]], shape=(2, 2), dtype=float64)

Теперь давайте попробуем умножить матрицу. Я создам два простых тензора tensor_011 и tensor_012.

tensor_011 = tf.constant([[2,2],[4,4]])
tensor_012 = tf.constant([[2,3],[4,5]])

Имейте в виду, что при умножении матриц внутренние размеры должны совпадать. Например, умножение (3, 5) * (3, 5) не сработает, но сработает (3, 5) * (5, 3).

Окончательная форма получившейся матрицы будет ее внешним размером. Итак, тензор 3x5, умноженный на тензор 5x3, даст нам тензор 5x5. Мы будем использовать функцию tf.matmul для выполнения матричного умножения.

print(tf.matmul(tensor_011,tensor_012))
OUTPUT:
tf.Tensor(
[[12 16]
 [24 32]], shape=(2, 2), dtype=int32)

Далее давайте рассмотрим изменение формы и транспонирование матрицы. Как мы видели ранее, мы часто будем использовать изменение формы для изменения нашей матричной структуры при обучении нейронных сетей.

Например, матрица пикселей изображения 28x28 будет преобразована в одномерный массив из 784 пикселей для нейронной сети классификации изображений.

Чтобы изменить форму, мы используем функцию tf.reshape. Для транспонирования мы используем функцию tf.transpose. Если вы не знаете, что такое транспонирование, то оно преобразует строки в столбцы и строки в столбцы.

print(tf.reshape(tensor_011,[4,1]))
print(tf.transpose(tensor_011))
OUTPUT:
tf.Tensor(
[[2]
 [2]
 [4]
 [4]], shape=(4, 1), dtype=int32)
tf.Tensor(
[[2 4]
 [2 4]], shape=(2, 2), dtype=int32)

Наконец, давайте рассмотрим некоторые агрегатные операции, такие как минимум, максимум, стандартное отклонение, квадрат и квадратный корень.

Чтобы найти минимальное и максимальное значения, мы используем функции tf.reduce_min и tf.reduce_max. А чтобы найти сумму массива, мы используем функцию tf.reduce_sum.

tensor_013 = tf.constant([
    [1,2,3],
    [4,5,6],
    [7,8,9]
],dtype='float32')
print(tf.reduce_min(tensor_013))
print(tf.reduce_max(tensor_013))
print(tf.reduce_sum(tensor_013))
OUTPUT:
tf.Tensor(1.0, shape=(), dtype=float32)
tf.Tensor(9.0, shape=(), dtype=float32)
tf.Tensor(45.0, shape=(), dtype=float32)

Теперь для стандартного отклонения и дисперсии мы используем функцию tf.math.reduce_std и функцию tf.math.reduce_variance.

print(tf.math.reduce_std(tensor_013))
print(tf.math.reduce_variance(tensor_013))
OUTPUT:
tf.Tensor(2.5819888, shape=(), dtype=float32)
tf.Tensor(6.6666665, shape=(), dtype=float32)

Давайте найдем квадрат, квадратный корень и логарифм каждого значения в тензоре.

print(tf.sqrt(tensor_013))
print(tf.square(tensor_013))
print(tf.math.log(tensor_013))
OUTPUT:
tf.Tensor(
[[1.        1.4142135 1.7320508]
 [2.        2.236068  2.4494898]
 [2.6457512 2.828427  3.       ]], shape=(3, 3), dtype=float32)
tf.Tensor(
[[ 1.  4.  9.]
 [16. 25. 36.]
 [49. 64. 81.]], shape=(3, 3), dtype=float32)
tf.Tensor(
[[0.        0.6931472 1.0986123]
 [1.3862944 1.609438  1.7917595]
 [1.9459102 2.0794415 2.1972246]], shape=(3, 3), dtype=float32)

В этой статье мы изучили основы tensorflow. Теперь вы готовы работать с tensorflow и использовать его для моделирования данных.

Если вы хотите начать использовать эти знания и построить проект, вы можете ознакомиться с моим курсом Создание нейронной сети распознавания рукописного ввода с помощью Tensorflow. Вы также можете изучить продвинутые концепции TensorFlow, используя официальную документацию.

Заключение

Tensorflow — мощная библиотека для создания моделей глубокого обучения. В нем есть все инструменты, необходимые для создания нейронных сетей для решения таких задач, как классификация изображений, анализ настроений, прогнозирование фондового рынка и т. д. С появлением таких технологий, как ChatGPT, изучение тензорного потока даст вам преимущество на текущем рынке труда.

Надеюсь, вам понравилась эта статья. Вы можете узнать больше обо мне и моих статьях/видео на manishmshiva.com.

Повышение уровня кодирования

Спасибо, что являетесь частью нашего сообщества! Перед тем, как ты уйдешь:

🚀👉 Присоединяйтесь к коллективу талантов Level Up и найдите прекрасную работу