TensorFlow 2.0

Опубликовано: 30 Ноября, 2021

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

Что такое открытый исходный код и как благодаря ему TensorFlow стал таким успешным?
Открытый исходный код означает что-то, что люди (в основном разработчики) могут изменять, делиться, интегрировать, потому что все оригинальные конструктивные особенности открыты для всех. Это позволяет легко, эффективно и за очень короткое время расширять конкретное программное обеспечение или продукт. Эта функция позволила первоначальному создателю TensorFlow, то есть Google, легко перенести это на каждую платформу, доступную на рынке, включая Интернет, мобильные устройства, Интернет вещей, встроенные системы, пограничные вычисления и включая поддержку различных других языков, например JavaScript, Node.js, F #, C ++, C #, React.js, Go, Julia, Rust, Android, Swift, Kotlin и многие другие.
Наряду с этим появилась поддержка аппаратного ускорения для запуска крупномасштабных кодов машинного обучения. К ним относятся CUDA (библиотека для запуска кода машинного обучения на графических процессорах), TPU (модуль обработки тензорного кода - настраиваемое оборудование, предоставляемое Google, специально разработанное и разработанное для обработки тензоров с использованием TensorFlow) для конфигурации нескольких компьютеров, GPU, GPGPU, облачные TPU, ASIC ( Интегральные схемы для конкретных приложений) FPGA (Программируемые пользователем вентильные матрицы - используются исключительно для настраиваемого программируемого оборудования). Это также включает новые дополнения, такие как чипы NVIDIA Jetson TX2 и Intel Movidius.
Теперь вернемся к более новому и многофункциональному TensorFlow2.0:
Это графическая реализация изменений:

Схема модели

Добавлены следующие вещи:

  • Основной API теперь ничем не отличается от Keras: гибкий слой Keras теперь интегрирован поверх исходного кода TensorFlow, что делает его простым и легким в использовании. Это поможет добиться значительного прогресса и производительности в области машинного обучения и искусственного интеллекта.
  • Стремительная командная строка: эта простая командная строка помогает нам немедленно выполнить операцию без использования команды Session.run.
  • Упрощенный и интегрированный рабочий процесс:
    1. Использование tf.data для загрузки данных (или NumPy).
    2. Используйте Keras для построения модели (мы также можем использовать любые готовые оценщики).
    3. Используйте tf.function для выполнения графа DAG или используйте активное выполнение.
    4. Используйте стратегию распространения для моделей высокопроизводительных вычислений и глубокого обучения. (Для TPU, GPU и т. Д.).
    5. TF 2.0 стандартизирует сохраненную модель как сериализованную версию графика TensorFlow для множества различных платформ, начиная от Mobile, JavaScript, TensorBoard, TensorHub и т. Д.
  • Поддержка TensorFlow Lite и TensorFlow Edge Computing: это поможет разработчикам предоставить конечным устройствам эффективные сервисы машинного обучения и искусственного интеллекта. Это потребует очень меньшей вычислительной мощности наряду с более быстрой реализацией модели и конечными пользователями.
  • Новые расширения для веб-приложений и Node.js с использованием TensorFlow.js для новых и интерактивных веб-сайтов и приложений на основе ИИ.
  • Оптимизация TensorFlow для Android.
  • Интеграция TensorFlow для приложений на базе Swift и IOS.
  • Поддержка самого долгожданного предстоящего предложения WebGPU Chrome RFC.
  • Унифицированные парадигмы программирования (направленный ациклический граф / функциональный и стек / последовательный).
  • Поддержка TensorFlow AIY (искусственный интеллект для себя).
  • Интеграция tf.contrib в отдельные репозитории.
  • Улучшенная поддержка TPU и TPU, а также поддержка распределенных вычислений и поддержка до v3.
  • Улучшенная интеграция HPC для параллельных вычислений.
  • Интеграция сообщества для развития, поддержки и исследований.
  • Интеграция лучшей реализации пакета tf.contrib в основной пакет.
  • Поддержка сообщества для конкретных доменов.
  • Дополнительная поддержка для проверки и повторного использования модели.
  • Сквозные конвейеры и продукты машинного обучения доступны на TensorFlow Hub.

    Наконец, теперь мы можем легко и эффективно создавать большие модели машинного обучения и глубокого обучения на TensorFlow2.0 для конечных пользователей и внедрять их в больших масштабах.

    Примеры:
    Обучение нейронной сети категоризации данных MNSIT

    # Write Python3 code here
    import tensorflow as tf
    """The Fashion MNIST data is available directly in the tf.keras
    datasets API. You load it like this:"""
    mnist = tf.keras.datasets.fashion_mnist
    """Calling load_data on this object will give you two sets of two
    lists, these will be the training and testing values for the graphics
    that contain the clothing items and their labels."""
    (training_images, training_labels), (test_images, test_labels) = mnist.load_data()
    """You'll notice that all of the values in the number are between 0 and 255.
    If we are training a neural network, for various reasons it's easier if we
    treat all values as between 0 and 1, a process called '**normalizing**'...and
    fortunately in Python it's easy to normalize a list like this without looping.
    So, perform it like - """
    training_images = training_images / 255.0
    test_images = test_images / 255.0
    """Now you might be wondering why there are 2 sets...training and testing
    -- remember we spoke about this in the intro? The idea is to have 1 set of
    data for training, and then another set of data...that the model hasn't yet
    seen...to see how good it would be at classifying values. After all, when
    you're done, you're going to want to try it out with data that it hadn't
    previously seen!
    Let's now design the model. There are quite a few new concepts here,
    but don't worry, you'll get the hang of them.
    """
    model = tf.keras.models.Sequential([tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(
    128 , activation = tf.nn.relu),
    tf.keras.layers.Dense(
    10 , activation = tf.nn.softmax)])
    """**Sequential**: That defines a SEQUENCE of layers in the neural network
    **Flatten**: Remember earlier where our images were a square when
    you printed them out? Flatten just takes that square and turns it
    into a 1-dimensional set.
    **Dense**: Adds a layer of neurons
    Each layer of neurons needs an **activation function** to tell them what to
    do. There are lots of options, but just use these for now.
    **Relu** effectively means "If X>0 return X, else return 0" -- so what it does
    it only passes values 0 or greater to the next layer in the network.
    **Softmax** takes a set of values, and effectively picks the biggest one, so,
    for example, if the output of the last layer looks like [0.1, 0.1, 0.05, 0.1,
    9.5, 0.1, 0.05, 0.05, 0.05], it saves you from fishing through it looking for
    the biggest value, and turns it into [0,0,0,0,1,0,0,0,0] --
    The goal is to save a lot of coding!
    The next thing to do, now the model is defined, is to actually build it.
    You do this by compiling it with an optimizer and loss function as before --
    and then you train it by calling **model.fit ** asking it to fit your training
    data to your training labels -- ie have it figure out the relationship between
    the training data and its actual labels, so in future, if you have data that
    looks like the training data, then it can make a prediction for what that data
    would look like.
    """
    model. compile (optimizer = tf.keras.optimizers.Adam(),
    loss = 'sparse_categorical_crossentropy' ,
    metrics = [ 'accuracy' ])
    model.fit(training_images, training_labels, epochs = 5 )
    """Once it's done training -- you should see an accuracy value at the end of the
    final epoch. It might look something like 0.9098. This tells you that your
    neural network is about 91% accurate in classifying the training data. IE,
    it figured out a pattern match between the image and the labels that worked
    91% of the time. Not great, but not bad considering it was only trained for 5
    epochs and done quite quickly.
    But how would it work with unseen data? That's why we have the test images. We
    can call model.evaluate, and pass in the two sets, and it will report back the
    loss for each. Let's give it a try:
    """
    model.evaluate(test_images, test_labels)
    """ For me, that returned an accuracy of about .8838, which means it was
    about 88% accurate. As expected it probably would not do as well with *unseen*
    data as it did with data it was trained on!
    """

    Выход:

     Ожидаемая точность 88-91%
    

    Нетерпеливое исполнение:

    import tensorflow as tf
    import tensorflow.contrib.eager as tfe
    tfe.enable_eager_execution()
    x = [[ 2. ]]
    m = tf.matmul(x, x)
    print (m)

    Выход :

     tf.Tensor ([[4.]], shape = (1, 1), dtype = float32)