Python для алготрейдинга - страница 22
Вы упускаете торговые возможности:
- Бесплатные приложения для трейдинга
- 8 000+ сигналов для копирования
- Экономические новости для анализа финансовых рынков
Регистрация
Вход
Вы принимаете политику сайта и условия использования
Если у вас нет учетной записи, зарегистрируйтесь
Машинное обучение с помощью BigQuery на облачной платформе Google
Машинное обучение с помощью BigQuery на облачной платформе Google
В видео обсуждается содержание курса, посвященного использованию BigQuery для машинного обучения. BigQuery — это корпоративное хранилище данных, которое изначально использовалось внутри Google, а затем стало облачным сервисом. Это высоко масштабируемое и бессерверное решение, способное вмещать петабайты данных и обеспечивать быстрые результаты запросов. Инструкции курса основаны на реальных примерах из практики и помогают учащимся пройти через процесс создания моделей машинного обучения от поиска данных до создания моделей. На протяжении всего курса учащиеся используют BigQuery для создания своих моделей, требуя от них настройки учетной записи Google Cloud Platform (GCP), специфичной для BigQuery.
Видео объясняет руководящие принципы Google по масштабированию аппаратных ресурсов, подчеркивая решение масштабировать, а не увеличивать. Google понимает, что аппаратное обеспечение может выйти из строя в любой момент, поэтому дизайн должен учитывать потенциальные сбои. Кроме того, Google использует стандартное аппаратное обеспечение, доступное по цене и обеспечивающее гибкость поставщика. Горизонтальное масштабирование предпочтительнее масштабирования из-за высокой стоимости оборудования. Google разработал такие технологии, как GFS, MapReduce и Bigtable, которые привели к масштабируемой аппаратной архитектуре. Colossus заменил GFS и служит базовой распределенной подсистемой для технологий Google, включая BigQuery.
Лектор представляет обзор решения Google для баз данных Spanner, которое распространяется по всему миру и использует Colossus для управления распределенными транзакциями. Видео также демонстрирует процесс регистрации и управления платежными аккаунтами в Google Cloud Platform. Пользователи могут создать учетную запись GCP, посетив веб-сайт платформы, согласившись с условиями и предоставив необходимую информацию. Новым пользователям предоставляется кредит в размере 300 долларов США для использования в GCP, который можно отслеживать в разделе выставления счетов. Лектор советует настроить оповещения о бюджете, чтобы получать уведомления при достижении определенных целей по выставлению счетов.
Подробно обсуждаются создание и назначение BigQuery. Экспоненциальный рост данных Google потребовал разработки BigQuery, который позволяет выполнять интерактивные запросы к большим наборам данных. BigQuery может обрабатывать запросы независимо от того, включают ли они 50 строк или 50 миллиардов строк. Его нестандартный диалект SQL облегчает процесс обучения, и он может распараллелить выполнение SQL на тысячах машин. Хотя BigQuery хранит структурированные данные, он отличается от реляционных баз данных поддержкой вложенных типов записей в таблицах, что позволяет хранить вложенные структуры.
Объясняется архитектура BigQuery, подчеркивая ее подход к распараллеливанию. В отличие от большинства систем реляционных баз данных, которые выполняют один запрос на ядро, BigQuery предназначен для выполнения одного запроса на тысячах ядер, что значительно повышает производительность по сравнению с традиционными подходами. Механизм Dremel обеспечивает конвейеризацию запросов, позволяя другим запросам использовать доступные ядра, в то время как некоторые ожидают ввода-вывода. BigQuery использует подход с несколькими арендаторами, позволяющий нескольким клиентам одновременно выполнять запросы на одном и том же оборудовании, не затрагивая другие местоположения. Интерфейс BigQuery состоит из трех основных панелей, включая историю запросов, сохраненные запросы, историю заданий и разделы ресурсов для организации доступа к таблицам и представлениям.
Видео содержит подробное объяснение экранов и панелей в Google Cloud Console, характерных для BigQuery. В меню навигации отображаются ресурсы BigQuery, такие как наборы данных и таблицы, а раздел рабочей области SQL позволяет пользователям создавать запросы, работать с таблицами и просматривать историю своих заданий. На панели Explorer перечислены текущие проекты и их ресурсы, а панель Details предоставляет информацию о выбранных ресурсах и позволяет изменять схемы таблиц, экспорт данных и другие функции. Уточняется, что BigQuery не подходит для OLTP-приложений из-за отсутствия поддержки частых небольших обновлений на уровне строк. Хотя это и не база данных NoSQL, BigQuery использует диалект SQL и ближе к базе данных OLAP, предоставляя аналогичные преимущества и пригодность для многих вариантов использования OLAP.
Далее обсуждается определение Google BigQuery, подчеркивая его полностью управляемое, масштабируемое, экономичное и быстрое облако.
Вот дополнительные моменты, обсуждаемые в видео:
Формат хранения BigQuery. BigQuery использует столбчатый формат хранения, оптимизированный для повышения производительности запросов. Он хранит данные в сжатом и столбцовом виде, что позволяет эффективно обрабатывать определенные столбцы в запросе без доступа к ненужным данным. Этот формат особенно удобен для аналитических рабочих нагрузок, включающих агрегирование и фильтрацию.
Прием данных: BigQuery поддерживает различные методы приема данных. Он может напрямую загружать данные из таких источников, как Google Cloud Storage, Google Sheets и Google Cloud Bigtable. Он также предлагает интеграцию с другими инструментами обработки данных, такими как Dataflow и Dataprep, для операций ETL (извлечение, преобразование, загрузка).
Разделение данных и кластеризация. Для оптимизации производительности запросов BigQuery предоставляет такие функции, как секционирование и кластеризация. Разделение предполагает разделение больших наборов данных на более мелкие управляемые части на основе выбранного столбца (например, даты). Кластеризация дополнительно организует данные в каждом разделе на основе одного или нескольких столбцов, чтобы повысить производительность запросов за счет уменьшения объема сканируемых данных.
Управление доступом к данным и безопасность: BigQuery предлагает надежные средства управления доступом для управления безопасностью данных. Он интегрируется с Google Cloud Identity and Access Management (IAM), позволяя пользователям определять подробные разрешения на доступ на уровне проекта, набора данных и таблицы. BigQuery также поддерживает шифрование при хранении и передаче, обеспечивая защиту конфиденциальных данных.
Ценообразование данных и оптимизация затрат. В видео кратко рассказывается о модели ценообразования BigQuery. Он работает на основе оплаты по мере использования, взимая плату с пользователей в зависимости от объема данных, обработанных запросами. BigQuery предлагает такие функции, как кэширование запросов, которые могут снизить затраты, избегая избыточной обработки данных. Для минимизации затрат важно оптимизировать запросы и избегать ненужного сканирования данных.
Машинное обучение с помощью BigQuery: курс охватывает использование BigQuery для задач машинного обучения. BigQuery интегрируется со службами машинного обучения Google Cloud, такими как AutoML и TensorFlow, что позволяет пользователям использовать возможности BigQuery для подготовки данных и разработки функций перед обучением моделей машинного обучения.
Варианты использования и примеры: лектор упоминает различные варианты использования BigQuery в реальной жизни, например, анализ больших объемов данных журналов, проведение маркетинговых исследований, выполнение сегментации клиентов и выполнение сложных аналитических запросов на массивных наборах данных.
В целом, видео представляет собой обзор возможностей, архитектуры и ключевых функций BigQuery, подчеркивая его пригодность для крупномасштабного анализа данных и задач машинного обучения. В нем подчеркиваются преимущества использования полностью управляемого и масштабируемого облачного решения, такого как BigQuery, для эффективной обработки огромных объемов данных.
Визуализация данных с помощью matplotlib за 1 час
Визуализация данных с помощью matplotlib за 1 час
В этом видео инструктор рассказывает о важности визуализации данных в машинном обучении и объясняет, как она может помочь разобраться в больших объемах собранных данных. В курсе рассматриваются две основные библиотеки Python для визуализации данных, Matplotlib и Seaborn.
Преподаватель заявляет, что курс в первую очередь предназначен для инженеров по машинному обучению, инженеров по данным и специалистов по данным, которые хотят изучить Python. Чтобы проиллюстрировать использование Matplotlib, приведен простой пример построения кривой. Философия Matplotlib вращается вокруг использования существующего языка Python, который стал стандартом для построения моделей машинного обучения и обработки данных. Комбинируя Matplotlib с другими пакетами Python, пользователи могут воспользоваться многочисленными пакетами, доступными для различных задач.
В видео подчеркивается важность использования пакета NumPy вместе с Matplotlib для научных вычислений. В то время как Matplotlib может работать без NumPy, использование NumPy может значительно сэкономить время и усилия. NumPy предоставляет мощный объект многомерного массива и функции для управления им. Пример демонстрируется в видео, где кривая со 100 точками генерируется с использованием NumPy для вычисления координат x и y. Этот подход оказывается намного быстрее, чем выполнение операции с использованием чистого Python. Кроме того, в видео рассказывается о построении двух кривых на одном графике для сравнения, построении данных из файла путем извлечения и организации данных с использованием кода Python, а также о линейном построении точек вместо элементов.
В этом руководстве рассматривается создание различных типов гистограмм с использованием библиотеки Matplotlib. Представлена специальная функция для создания гистограмм «bar», которая принимает координату x для каждого столбца и высоту каждого столбца в качестве входных параметров. Настраивая дополнительные параметры, пользователи могут создавать различные эффекты и даже генерировать горизонтальные полосы с помощью функции «barh». В учебнике также рассматривается построение нескольких столбчатых диаграмм на одном графике и создание столбцов с накоплением с использованием специального параметра в функции «bar». Кроме того, в видео кратко рассказывается о создании круговых диаграмм с использованием функции «пирог».
В руководстве объясняются различные функции, используемые для визуализации данных с помощью Matplotlib. Первая рассматриваемая функция — это гистограммы, представляющие собой графическое представление распределения вероятностей. Обсуждаются функция «Hist» и ее параметры, позволяющие пользователям легко отображать данные в виде гистограмм. Вторая рассматриваемая функция — это ящичные диаграммы, которые облегчают сравнение распределений значений. В видео объясняются компоненты коробчатой диаграммы, включая квартили, медиану, среднее значение и статистические величины набора данных, а также демонстрируется, как их генерировать с помощью функции «ящичная диаграмма». Наконец, в учебнике рассматривается изменение графиков с использованием разных цветов и стилей, например определение цветов с использованием триплетов, четверок или имен цветов HTML, а также установка цвета графика кривой.
Видео продолжается объяснением того, как добавить цвет к точечным диаграммам, гистограммам и круговым диаграммам с помощью параметра «цвет». Этот параметр позволяет пользователям управлять отдельными цветами точек или изменять общий цвет для всех точек. В видео также затрагивается вопрос импорта библиотек в виде модулей, использования псевдонимов для упрощения написания кода и уточнения представления переменных. Подчеркивается, что почти все в Matplotlib и Python включает функции, такие как функция «pi» и функция «show».
Далее в учебнике рассматриваются пользовательские цветовые схемы и образцы линий при создании коробчатых диаграмм, маркеров и форм линий. Он демонстрирует создание пользовательских маркеров с использованием предопределенных форм и определение пользовательских маркеров с использованием символов математического текста. Кроме того, в нем объясняется, как легко изменить настройки Matplotlib по умолчанию с помощью объекта централизованной конфигурации, что позволяет пользователям адаптировать визуальный стиль, например черный фон и белые аннотации, к различным контекстам использования.
Ведущий объясняет, как сохранить график в файл с помощью функции «savefig» в Matplotlib. Они также охватывают добавление аннотаций к графику, включая заголовок, метки для осей x и y, ограниченную рамку и стрелки. Видео демонстрирует процесс добавления этих аннотаций для повышения визуальной ясности и понимания графика. Кроме того, он демонстрирует, как вручную управлять расстоянием между делениями в Matplotlib для точной настройки. В видео освещаются различные функции, доступные в Matplotlib для аннотирования графиков и повышения их понятности для читателей.
Далее инструктор обсуждает визуализацию данных с помощью Matplotlib и представляет Seaborn, высокоуровневый интерфейс для Matplotlib. Seaborn предоставляет другие параметры и функции по сравнению с Matplotlib. Инструктор демонстрирует, как создавать визуализации с использованием встроенного набора данных Seaborn и цветных карт. Видео завершается представлением примеров создания факторного графика и использования цветовых карт для построения данных. На этих примерах зрители получают представление об использовании различных функций и инструментов в Matplotlib и Seaborn для улучшения своих навыков визуализации данных.
В видео объясняется, как масштабировать графики с помощью функции Seaborn set_context. Эта функция позволяет пользователям управлять элементами графика, такими как размер, в зависимости от контекста, в котором будет отображаться график. Затем разъясняется различие между двумя типами функций Seaborn: функциями уровня осей и функциями уровня фигур. Функции уровня осей работают на уровне осей и возвращают объект осей, в то время как функции уровня фигур создают графики, которые включают оси, организованные осмысленным образом. Наконец, видео содержит рекомендации по настройке осей для блочной диаграммы с использованием объекта подграфиков осей Matplotlib.
Этот всеобъемлющий видеоурок охватывает широкий круг тем, связанных с визуализацией данных с помощью Matplotlib и Seaborn. Он начинается с ознакомления с важностью визуализации данных в машинном обучении и использованием Matplotlib в качестве мощной библиотеки. В нем показано, как строить кривые, создавать гистограммы, генерировать гистограммы и диаграммы, а также настраивать цвета, маркеры и стили линий. В учебнике также рассказывается о сохранении графиков, добавлении аннотаций и управлении интервалом деления. Кроме того, он представляет Seaborn как альтернативный инструмент визуализации с собственным набором функций и возможностей. Следуя этому руководству, зрители могут улучшить свои навыки визуализации данных и эффективно сообщать о своих выводах с помощью этих мощных библиотек Python.
Руководство по глубокому обучению с помощью Python, TensorFlow и Keras
Руководство по глубокому обучению с помощью Python, TensorFlow и Keras
Приветствую всех и добро пожаловать в долгожданное обновление по глубокому обучению и Python с TensorFlow, а также в новое руководство по Chaos. Прошло более двух лет с тех пор, как я в последний раз освещал основы глубокого обучения в Python, и за это время были достигнуты значительные успехи. Погружение в глубокое обучение и работа с моделями глубокого обучения стало намного проще и доступнее.
Если вам интересно углубиться в код TensorFlow более низкого уровня и запутанные детали, вы все равно можете обратиться к старому видео. Однако, если вы хотите начать работу с глубоким обучением, вам больше не нужно проходить через это, потому что теперь у нас есть удобные высокоуровневые API, такие как Chaos, которые работают поверх TensorFlow. Эти API-интерфейсы делают глубокое обучение невероятно простым, позволяя любому, даже не имеющему предварительных знаний о глубоком обучении, следовать за ним.
В этом уроке мы кратко рассмотрим нейронные сети. Для начала давайте разберемся с основными компонентами нейронной сети. Основная цель любой модели машинного обучения, включая нейронные сети, — сопоставить входные данные с выходными. Например, учитывая входные данные X1, X2 и X3, мы стремимся определить, соответствует ли результат собаке или кошке. В этом случае выходной слой состоит из двух нейронов, представляющих возможность быть собакой или кошкой.
Для достижения этого сопоставления мы можем использовать один скрытый слой, где каждый вход, X1, X2 и X3, связан с нейронами в скрытом слое. Каждое из этих соединений имеет уникальный вес, связанный с ним. Однако, если мы ограничимся одним скрытым слоем, отношения между входами и выходами будут линейными. Чтобы зафиксировать нелинейные отношения, которые часто встречаются в сложных задачах, нам нужны два или более скрытых слоя. Нейронную сеть с двумя или более скрытыми слоями часто называют глубокой нейронной сетью.
Давайте добавим еще один скрытый слой, полностью соединив его с предыдущим слоем. Каждая связь между слоями имеет свой уникальный вес. В конечном итоге выходные данные получаются из последнего слоя, где каждое соединение с выходным слоем имеет уникальный вес. На уровне отдельного нейрона нейрон получает входные данные, которые могут быть либо значениями входного слоя (X1, X2, X3), либо входными данными от других нейронов. Эти входные данные суммируются с учетом связанных с ними весов. Кроме того, функция активации применяется для имитации срабатывания нейрона или нет. Общие функции активации включают ступенчатую функцию или сигмовидную функцию, которая возвращает значения от 0 до 1. В нашей нейронной сети выходной слой использует сигмовидную функцию активации, присваивая вероятности каждому классу (собаке или кошке). Затем функция Arg max используется для определения прогнозируемого класса на основе наибольшей вероятности.
Теперь, когда у нас есть общее представление о нейронных сетях, давайте приступим к их созданию с помощью TensorFlow. Во-первых, убедитесь, что у вас установлен TensorFlow, выполнив команду «pip install --upgrade tensorflow». Вы можете импортировать TensorFlow как «tf» и проверить текущую версию, используя «tf.version». Для этого руководства рекомендуется Python 3.6 или выше, хотя ожидается, что TensorFlow будет поддерживать Python 3.7 и более поздние версии в будущем.
Далее мы импортируем набор данных для работы. Мы будем использовать набор данных MNIST, который состоит из 28x28 изображений рукописных цифр от 0 до 9. Эти изображения будут переданы в нейронную сеть, и сеть будет предсказывать соответствующую цифру. Мы разделим набор данных на обучающие и тестовые переменные: X_train, Y_train, X_test и Y_test.
Чтобы обеспечить лучшую производительность, мы нормализуем данные. Значения пикселей изображений в настоящее время варьируются от 0 до 255, поэтому мы будем масштабировать их от 0 до 1, используя функцию TF.keras.utils.normalize.
Для построения модели будем использовать высокоуровневый API Chaos, упрощающий процесс создания и обучения нейронных сетей в TensorFlow. Chaos предоставляет последовательную модель под названием Sequential, которая позволяет нам складывать слои один за другим.
Вот пример того, как вы можете создать модель нейронной сети с помощью Chaos:
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense
# Create a sequential model
model = Sequential()
# Add a flatten layer to convert the input into a 1D array
model.add(Flatten(input_shape=(28, 28)))
# Add a dense layer with 128 neurons and ReLU activation
model.add(Dense(128, activation='relu'))
# Add another dense layer with 10 neurons for the output and softmax activation
model.add(Dense(10, activation='softmax'))
# Compile the model
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
В приведенном выше коде мы импортируем необходимые модули из TensorFlow и Chaos. Мы создаем модель Sequential и добавляем к ней слои с помощью метода add. Первый слой представляет собой слой Flatten, который преобразует ввод 2D (изображения 28x28) в массив 1D. Затем мы добавляем плотный слой со 128 нейронами и активацией ReLU. Наконец, мы добавляем выходной слой с 10 нейронами (соответствующими 10 цифрам) и активацией softmax.
После определения модели мы компилируем ее с помощью метода compile. Мы указываем оптимизатор (в данном случае «адам»), функцию потерь («sparse_categorical_crossentropy» для многоклассовой классификации) и метрики для оценки во время обучения.
Теперь, когда мы определили и скомпилировали нашу модель, мы можем приступить к ее обучению на наборе данных MNIST. Мы будем использовать метод подгонки для обучения модели.
# Train the model model.fit(X_train, Y_train, epochs= 10 , validation_data=(X_test, Y_test))
В приведенном выше коде мы передаем данные обучения (X_train и Y_train) методу подгонки вместе с количеством эпох для обучения. Мы также предоставляем данные проверки (X_test и Y_test), чтобы оценить производительность модели на невидимых данных во время обучения.
После обучения модели мы можем делать прогнозы с помощью метода прогнозирования:
# Make predictions predictions = model.predict(X_test)
В приведенном выше коде мы передаем тестовые данные (X_test) методу прогнозирования, и он возвращает прогнозируемые вероятности для каждого класса.
Это краткий обзор создания и обучения нейронной сети с использованием Chaos в TensorFlow. Вы можете дополнительно изучить различные слои, функции активации, оптимизаторы и другие параметры, чтобы настроить свою модель.
дополнительные методы и концепции, связанные с построением и обучением нейронных сетей.
Методы регуляризации:
Dropout: Dropout — это метод регуляризации, используемый для предотвращения переобучения. Он случайным образом устанавливает часть входных единиц в 0 при каждом обновлении во время обучения, что помогает предотвратить слишком сильную зависимость модели от какого-либо конкретного набора функций.
Регуляризация L1 и L2: Регуляризация L1 и L2 — это методы, используемые для добавления штрафа к функции потерь для предотвращения больших весов в сети. Регуляризация L1 добавляет абсолютное значение весов к функции потерь, поощряя разреженность, в то время как регуляризация L2 добавляет к функции потерь квадраты весов, поощряя малые веса.
Расширенные функции активации:
Leaky ReLU: Leaky ReLU — это функция активации, которая решает проблему «умирающего ReLU», допуская небольшой наклон для отрицательных входных данных. Он вводит небольшой отрицательный наклон, когда вход отрицательный, что помогает предотвратить гибель нейронов во время обучения.
Экспоненциальная линейная единица (ELU): ELU — это функция активации, которая сглаживает выходные данные для отрицательных входных данных, позволяя активации принимать отрицательные значения. Было показано, что это помогает улучшить обучение нейронных сетей и уменьшить склонность к положительным значениям.
Swish: Swish — это функция активации, которая выполняет плавную интерполяцию между линейной и сигмовидной функциями. Было показано, что в некоторых случаях он дает лучшие результаты по сравнению с другими функциями активации, такими как ReLU и сигмоид.
Трансферное обучение. Трансферное обучение — это метод, который использует предварительно обученные модели для решения новых задач или повышения производительности модели в связанной задаче. Вместо обучения модели с нуля вы можете использовать предварительно обученную модель в качестве отправной точки и настроить ее для конкретной задачи или набора данных. Это особенно полезно, когда у вас есть ограниченные данные для вашей конкретной задачи.
Настройка гиперпараметров. Гиперпараметры — это параметры, которые не изучаются моделью, но влияют на процесс обучения, такие как скорость обучения, размер пакета, количество слоев и т. д. Настройка этих гиперпараметров может значительно повлиять на производительность модели. Такие методы, как поиск по сетке, случайный поиск и байесовская оптимизация, могут использоваться для систематического поиска в пространстве гиперпараметров и поиска наилучшей комбинации.
Оценка модели. Оценка производительности модели имеет решающее значение для оценки ее эффективности. Общие метрики оценки для задач классификации включают точность, воспроизводимость, полноту, оценку F1 и площадь под кривой рабочих характеристик приемника (ROC AUC). Важно выбрать подходящие показатели в зависимости от решаемой проблемы и характера данных.
Обработка несбалансированных наборов данных. Несбалансированные наборы данных возникают, когда распределение классов не равно, что может привести к необъективным моделям. Решить эту проблему могут такие методы, как избыточная выборка класса меньшинства, недостаточная выборка класса большинства или их комбинация. Кроме того, использование показателей оценки, таких как точность, полнота и оценка F1, может обеспечить лучшее понимание производительности модели на несбалансированных наборах данных.
Помните, что создание и обучение нейронных сетей — это повторяющийся процесс. Он включает в себя экспериментирование, тонкую настройку и постоянное совершенствование для достижения желаемых результатов.
Загрузка собственных данных — основы глубокого обучения с помощью Python, TensorFlow и Keras, часть 2
Загрузка собственных данных — основы глубокого обучения с помощью Python, TensorFlow и Keras, часть 2
Добро пожаловать во вторую часть нашего руководства по глубокому изучению Python TensorFlow в Karros. В этом руководстве мы сосредоточимся на загрузке внешнего набора данных. В частности, мы будем использовать набор данных о кошках и собаках от Microsoft, изначально созданный для Kaggle. Цель состоит в том, чтобы научить нейронную сеть определять, содержит ли изображение кошку или собаку.
Для начала загрузите набор данных о кошках и собаках с веб-сайта Microsoft. После того, как вы загрузили и извлекли набор данных, вы должны увидеть два каталога: «кошка» и «собака». Эти каталоги содержат изображения кошек и собак соответственно. В каждом каталоге должно быть значительное количество образцов, около 12 500, обеспечивающих достаточное количество примеров для обучения нашей модели.
Теперь давайте перейдем к части кодирования. Нам нужно импортировать несколько библиотек: numpy как np, matplotlib.pyplot как plt и OpenCV как cv2. Если у вас не установлены эти библиотеки, вы можете использовать pip для их установки.
Далее мы определим каталог данных, в котором находится наш набор данных. Вы можете указать путь к вашему набору данных соответственно. Мы также определим категории как «собака» и «кошка», чтобы они соответствовали каталогам в нашем наборе данных.
Мы будем перебирать каждую категорию и соответствующие изображения, используя библиотеку ОС. Для каждого изображения мы преобразуем его в оттенки серого с помощью библиотеки cv2. Мы выбрали оттенки серого, потому что считаем, что цвет не имеет решающего значения для различения кошек и собак в этой конкретной задаче.
Для визуализации изображений мы будем использовать matplotlib.pyplot. Мы покажем пример изображения, используя plt.imshow и карту цветов в градациях серого. Этот шаг позволяет нам убедиться, что изображения загружены правильно.
После проверки изображений мы приступим к изменению их размера до единой формы. Нам нужно выбрать целевой размер, например 50x50 пикселей, чтобы обеспечить согласованность. Мы изменим размер изображений с помощью функции cv2.resize и сохраним массивы изображений с измененным размером.
Теперь мы создадим обучающий набор данных. Мы инициализируем пустой список с именем «training_data» и определяем функцию с именем «create_training_data». В этой функции мы перебираем изображения и присваиваем числовые метки (0 для собак, 1 для кошек), используя индекс категории в списке «категории».
Для каждого изображения мы изменяем его размер до выбранного целевого размера. Мы добавляем массив изображений с измененным размером и соответствующую ему метку в список training_data. Мы также обрабатываем любые потенциальные исключения, связанные с неработающими изображениями в наборе данных.
После того, как мы создали набор обучающих данных, мы должны проверить баланс данных. В такой задаче бинарной классификации важно иметь равное количество образцов для каждого класса (50% собак и 50% кошек). Несбалансированные данные могут привести к необъективным прогнозам модели. Если ваши данные несбалансированы, вы можете использовать веса классов во время обучения, чтобы смягчить эту проблему.
Чтобы обеспечить случайность и предотвратить изучение порядка изображений моделью, мы перемешиваем обучающие данные с помощью функции random.shuffle.
Теперь, когда наши данные перемешаны, мы можем упаковать их в переменные для функций (X) и меток (Y). Мы инициализируем пустые списки для X и Y и повторяем обучающие данные, добавляя функции и метки к соответствующим спискам. Наконец, мы преобразуем X в массив NumPy и изменяем его форму, используя np.array и форму каждой функции.
На данный момент мы подготовили наши данные для обучения нейронной сети. Теперь мы готовы приступить к дальнейшим шагам, таким как разделение данных на наборы для обучения и проверки, построение модели и ее обучение с использованием TensorFlow.
Минус 1 — это заполнитель, который автоматически вычисляет размер на основе длины массива и формы каждого элемента. Итак, в этом случае мы изменяем массив X, чтобы он имел форму (-1, image_size, image_size). Это гарантирует, что данные находятся в правильном формате для ввода в нейронную сеть.
Далее нам нужно нормализовать значения пикселей изображений. В настоящее время значения пикселей находятся в диапазоне от 0 до 255, что соответствует интенсивности оттенков серого. Нейронные сети обычно работают лучше, когда входные данные нормализованы, то есть значения масштабируются до меньшего диапазона. Мы можем добиться этого, разделив значения пикселей на 255,0, что позволит масштабировать их от 0 до 1,0. Это можно сделать с помощью следующего кода:
x = x / 255.0
Сверточные нейронные сети — основы глубокого обучения с помощью Python, TensorFlow и Keras, часть 3
Сверточные нейронные сети — основы глубокого обучения с помощью Python, TensorFlow и Keras, часть 3
Всем привет и добро пожаловать в третью часть нашей серии руководств по Deep Learning with Python, TensorFlow и Keras. В этом видео мы сосредоточимся на сверточных нейронных сетях (CNN) и на том, как их применять для классификации собак и кошек с использованием набора данных, который мы создали в предыдущем видео.
Прежде чем мы углубимся в CNN, давайте быстро рассмотрим, как они работают и почему они полезны для данных изображений. CNN включают несколько этапов: свертка, объединение, а затем еще одна свертка и объединение. Основная идея свертки заключается в извлечении полезных функций из изображения. Мы используем сверточное окно, обычно представленное в виде матрицы (например, 3x3), для сканирования изображения и упрощения информации в окне до одного значения. Затем окно смещается, и этот процесс повторяется несколько раз. Шаг, который определяет, насколько сильно перемещается окно, также можно отрегулировать.
С Keras мы можем указать размер окна, а большинство других деталей позаботятся автоматически. Если вы хотите глубже вникнуть в тонкости глубокого обучения, я рекомендую ознакомиться с серией руководств «Практическое машинное обучение», где более подробно объясняется внутренняя работа, особенно для необработанного кода TensorFlow.
На выходе сверточный слой представляет собой набор признаков, извлеченных из изображения. Затем эти функции обычно передаются через слой пула, наиболее распространенным типом которого является максимальный пул. Максимальный пул выбирает максимальное значение в окне и многократно сдвигает его, эффективно снижая дискретизацию данных.
Идея более высокого уровня, лежащая в основе CNN, заключается в том, что они постепенно извлекают более сложные функции из изображения по мере того, как вы углубляетесь в сеть. Начальные слои могут идентифицировать края и линии, в то время как более глубокие слои могут распознавать более сложные формы, такие как круги или квадраты. В конце концов, сеть может научиться идентифицировать определенные объекты или шаблоны.
Чтобы реализовать CNN, нам нужно импортировать необходимые библиотеки. Мы импортируем TensorFlow и модули Keras, которые будем использовать, такие как Sequential, Dense, Dropout, Activation, Conv2D и MaxPooling2D. Мы также импортируем pickle для загрузки нашего набора данных.
Прежде чем подавать данные в нейронную сеть, мы должны рассмотреть их нормализацию. В нашем случае мы можем масштабировать данные пикселей, разделив их на 255, поскольку значения пикселей находятся в диапазоне от 0 до 255. В качестве альтернативы мы можем использовать функцию нормализации из хаоса.utils для более сложных сценариев нормализации.
Далее мы начинаем строить нашу модель с помощью Sequential API. Мы добавляем слой Conv2D с 64 единицами и размером окна 3x3. input_shape устанавливается динамически с помощью X.shape. Затем мы добавляем слой активации, используя выпрямленную линейную функцию активации (ReLU). После этого мы добавляем слой максимального пула с размером окна 2x2.
Мы повторяем этот процесс, добавляя еще один слой Conv2D и соответствующий слой максимального пула. На данный момент у нас есть 2D сверточная нейронная сеть.
Чтобы передать извлеченные объекты в полносвязный слой, нам нужно сгладить данные. Мы добавляем слой Flatten перед добавлением последнего слоя Dense с 64 узлами. Наконец, мы добавляем выходной слой с одним узлом и указываем функцию активации, которая может быть категориальной или бинарной.
Мы компилируем модель, указав функцию потерь (категориальная или бинарная кросс-энтропия), оптимизатор (например, Адам) и метрики для оценки производительности модели (например, точность).
Чтобы обучить модель, мы используем метод подгонки, передавая наши входные данные X и метки Y. Мы также можем указать размер партии (например, 32).
Мы будем использовать следующий код для обучения модели:
model.fit(X, Y, batch_size= 32 , validation_split= 0.1 )
Этот код будет обучать модель, используя входные данные X и соответствующие метки Y. Мы устанавливаем размер пакета равным 32, что означает, что модель будет обрабатывать 32 выборки за раз во время обучения. Для параметра validation_split установлено значение 0,1, что означает, что 10% данных будут использоваться для проверки при обучении модели.
Как только модель обучена, мы можем оценить ее производительность, используя тестовые данные. Мы можем использовать следующий код для оценки модели:
model.evaluate(X_test, Y_test)
Здесь X_test и Y_test представляют тестовые данные и метки соответственно. Этот код вернет значение потерь и точность модели на тестовых данных.
После оценки модели мы можем использовать ее для прогнозирования новых, невидимых данных. Мы можем использовать функцию предсказания (), чтобы получить предсказанные метки для новых данных. Вот пример:
predictions = model.predict(X_new)
predicted_labels = np.argmax(predictions, axis= 1 )
Вот и все! Теперь вы обучили модель сверточной нейронной сети классифицировать собак и кошек и использовали ее для прогнозирования новых данных. Не забудьте сохранить обученную модель для использования в будущем, если это необходимо.
Анализ моделей с помощью TensorBoard — глубокое обучение с помощью Python, TensorFlow и Keras, часть 4
Анализ моделей с помощью TensorBoard — глубокое обучение с помощью Python, TensorFlow и Keras, часть 4
Добро пожаловать в четвертую часть серии руководств «Глубокое обучение с помощью Python: TensorFlow и Keras». В этом и следующем видео мы обсудим, как анализировать и оптимизировать наши модели с помощью TensorBoard. TensorBoard — это мощный инструмент, который позволяет нам визуализировать обучение наших моделей с течением времени. Его основная цель — помочь нам понять различные аспекты производительности нашей модели, такие как точность, точность проверки, потери и потери проверки. Кроме того, в TensorBoard есть более продвинутые функции, которые мы можем изучить в будущих руководствах.
Прежде чем мы углубимся в TensorBoard, давайте обратимся к небольшой детали. Хотя это и не имеет решающего значения для этого урока, я хочу отметить, что даже небольшие модели, как правило, потребляют значительный объем памяти графического процессора. Если вы планируете запускать несколько моделей одновременно, вы можете указать долю памяти графического процессора, которую должна использовать каждая модель. Делая это, вы можете избежать потенциальных проблем при запуске нескольких моделей или столкновении с ограничениями памяти. Например, я обычно настраиваю модель на использование одной трети памяти графического процессора. Этот подход оказался полезным при одновременном запуске нескольких моделей, например, в серии «Python Plays GTA», включающей обнаружение объектов и автономное вождение. Это просто удобный совет, который может сэкономить вам время и нервы.
Теперь продолжим основную тему. Первое, что я хочу решить, это добавить функцию активации после плотного слоя. С моей стороны было ошибкой не включить его изначально. Добавление функции активации необходимо, поскольку без нее плотный слой становится линейной функцией активации, что не подходит для наших целей. Мы хотим избежать регрессии и обеспечить оптимальную работу нашей модели. Итак, давайте быстро исправим это, вставив функцию активации перед плотным слоем.
После внесения этой поправки мы должны наблюдать значительное улучшение точности. Пока модель обучается, давайте на минутку изучим документацию TensorFlow и узнаем о различных доступных обратных вызовах Keras. В нашем случае мы будем использовать обратный вызов TensorBoard для взаимодействия с TensorBoard. Однако стоит отметить, что есть и другие полезные обратные вызовы, такие как ранняя остановка на основе определенных параметров, планирование скорости обучения и контрольные точки модели. Контрольные точки модели особенно полезны, когда вы хотите сохранять модель через определенные промежутки времени, такие как наилучшие потери или точность проверки. Сейчас давайте сосредоточимся на обратном вызове TensorBoard, но я могу кратко коснуться других обратных вызовов в будущем видео.
Чтобы использовать обратный вызов TensorBoard, нам нужно импортировать его из модуля обратных вызовов TensorFlow Keras. Добавьте следующую строку кода для импорта TensorBoard:
from tensorflow.keras.callbacks import TensorBoard
Теперь, когда мы импортировали необходимый модуль, давайте выполним некоторые действия. Всегда рекомендуется давать модели осмысленное имя, особенно при работе с несколькими моделями. В этом случае мы можем назвать нашу модель как-нибудь вроде «cats_vs_dogs_CNN_64x2». Кроме того, давайте добавим временную метку к имени, чтобы обеспечить уникальность. Включение метки времени полезно при переобучении модели или во избежание путаницы с версиями модели. Итак, в начале нашего кода давайте определим имя модели и отметку времени следующим образом:
import time model_name = f"cats_vs_dogs_CNN_64x2_ { int (time.time())} "
tensorboard_callback = TensorBoard(log_dir= f"logs/ {model_name} " )
Кроме того, тензорная доска позволяет нам анализировать и оптимизировать наши модели, предоставляя визуализацию процесса обучения. В первую очередь он фокусируется на таких показателях, как точность, точность проверки, потери и потери проверки. Эти показатели помогают нам понять, как наша модель работает с течением времени, и определить области для улучшения. В то время как точность и потери обычно контролируются, Tensor Board предлагает более продвинутые функции, которые мы можем изучить в будущем.
Чтобы начать использовать тензорную доску, нам сначала нужно сделать небольшое дополнение к нашему коду. Хотя это не имеет решающего значения для этого урока, стоит упомянуть. Добавив несколько строк кода, мы можем выделить определенную часть памяти графического процессора для нашей модели. Это полезно при одновременном запуске нескольких моделей или при возникновении проблем с VRAM. Это позволяет нам контролировать распределение GPU и избегать возможных сбоев или переполнения памяти. В нашем случае мы выделяем треть GPU для модели. Это обеспечивает плавное выполнение и предотвращает любые конфликты при работе с другими моделями или проектами.
Двигаясь дальше, давайте сосредоточимся на реализации тензорной доски. Во-первых, нам нужно импортировать необходимые зависимости. Мы импортируем модуль «tensorboard» из пакета «tensorflow.keras.callbacks». Этот модуль обеспечивает функциональность обратного вызова для тензорной платы.
Далее мы хотим присвоить нашей модели осмысленное имя. Присвоение каждой модели отдельного имени необходимо при работе с несколькими моделями. Это помогает нам отслеживать эксперименты и избегать путаницы. В этом случае мы назовем нашу модель «cat's_first_dog_CNN_64x2_good_enough». Кроме того, мы добавляем временную метку к имени, используя текущее значение времени. Это обеспечивает уникальность и предотвращает случайную перезапись моделей.
Назвав нашу модель, мы можем определить объект обратного вызова тензорной доски. Мы создаем экземпляр класса «TensorBoard» и присваиваем его переменной «tensorboard». Мы передаем конструктору путь к каталогу журнала. Каталог журналов — это место, где Tensor Board будет хранить журналы и данные, относящиеся к нашей модели. Мы используем строковое форматирование, чтобы включить имя модели в путь к каталогу журнала.
Как только у нас будет готов объект обратного вызова, мы можем включить его в процесс обучения нашей модели. В методе «подгонки» нашей модели мы передаем объект обратного вызова в параметр «обратные вызовы» в виде списка. В этом случае у нас есть только один обратный вызов, который является обратным вызовом тензорной доски. Однако стоит отметить, что при необходимости вы можете включить в список несколько обратных вызовов.
Теперь с интегрированным обратным вызовом мы можем обучить нашу модель. Для этого примера мы устанавливаем количество эпох равным 10. Однако не стесняйтесь настраивать количество эпох в соответствии с вашими требованиями. По мере обучения модели tensor board начнет генерировать журналы и визуализации на основе указанных метрик.
Чтобы увидеть тензорную доску в действии, нам нужно открыть командное окно или терминал и перейти в каталог, содержащий файлы журнала. Оказавшись в правильном каталоге, мы запускаем команду tensor board, введя «tensorboard --logdir logs» в командной строке. Эта команда запускает сервер Tensor Board и предоставляет локальный URL-адрес, по которому мы можем получить доступ к интерфейсу Tensor Board.
После запуска tensor board мы можем открыть веб-браузер и ввести URL-адрес, указанный в командной строке. Это отобразит интерфейс тензорной доски, где мы можем визуализировать ход обучения нашей модели. Интерфейс показывает различные графики, включая точность в выборке, потери в выборке, точность за пределами выборки и потери за пределами выборки. Мы анализируем эти показатели, чтобы отслеживать производительность модели и принимать обоснованные решения относительно ее оптимизации.
Наблюдая за графиками, мы можем определить закономерности и тенденции в поведении модели. Например, если потери при проверке начинают увеличиваться, а точность проверки остается неизменной или снижается, это указывает на переобучение. С другой стороны, если и точность проверки, и потери со временем улучшаются, это говорит о том, что модель обучается эффективно.
Плата Tensor предоставляет мощную платформу для анализа и оптимизации моделей. Его визуализации дают ценную информацию о процессе обучения и облегчают принятие решений. Используя тензорную доску, мы можем упростить процесс разработки модели и добиться лучших результатов.
В следующей части этой серии руководств мы углубимся в расширенные функции тензорной доски, включая гистограммы, распределения и встраивания. Эти функции обеспечивают дополнительную детализацию и позволяют нам получить более полное представление о наших моделях. Оставайтесь с нами для следующего видео, в котором мы исследуем эти захватывающие возможности.
Вот и все для этого урока. Спасибо за просмотр, и увидимся в следующем видео!
Оптимизация с помощью TensorBoard — глубокое обучение с Python, TensorFlow и Keras часть 5
Оптимизация с помощью TensorBoard — глубокое обучение с Python, TensorFlow и Keras часть 5
Привет всем и добро пожаловать в пятую часть серии руководств по глубокому обучению с помощью Python TensorBoard и Keras. В этом руководстве мы сосредоточимся на TensorBoard и на том, как мы можем использовать его для оптимизации моделей путем визуализации различных попыток создания моделей. Давайте погрузимся в это!
Во-первых, давайте проанализируем модель и определим аспекты, которые мы можем настроить, чтобы улучшить ее производительность. Хотя наша текущая модель достигла точности около 79%, мы считаем, что можем добиться большего. Некоторые потенциальные области для оптимизации включают оптимизатор, скорость обучения, количество плотных слоев, единицы на слой, единицы активации, размер ядра, шаг, скорость затухания и многое другое. Имея множество вариантов для изучения, мы можем в конечном итоге протестировать тысячи моделей. Итак, с чего начнем?
Чтобы упростить задачу, начнем с самых простых модификаций. Мы сосредоточимся на настройке количества слоев, узлов на слой и на том, следует ли включать плотный слой в конце. В качестве количества плотных слоев мы будем рассматривать ноль, один или два. Что касается размеров слоя, мы будем использовать значения 32, 64 и 128. Эти значения являются условными, и вы можете выбрать другие в соответствии со своими предпочтениями.
Теперь давайте внедрим эти изменения в наш код. Мы определим некоторые переменные для выбора, который мы хотим сделать, например, количество плотных слоев и размеры слоев. Мы пройдемся по этим переменным, чтобы создать различные комбинации моделей. Кроме того, мы создадим имя для каждой модели, отражающее ее конфигурацию.
Получив конфигурации модели, мы можем приступить к их применению в нашем коде. Мы соответствующим образом обновим структуру модели, учитывая входную форму, сверточные слои, плотные слои и выходной слой. Мы также позаботимся о том, чтобы размеры слоев были правильно скорректированы.
Со всеми внесенными изменениями пришло время запустить код. Однако, поскольку обучение многочисленных моделей может занять много времени, я уже запустил код и сохранил результаты. Перейдем к анализу результатов с помощью TensorBoard.
Мы загружаем журналы TensorBoard и наблюдаем за различными комбинациями моделей. Модели организованы на основе их производительности, в частности, потерь при проверке. Мы фокусируемся на наиболее эффективных моделях и отмечаем их конфигурации.
Из результатов становится очевидным, что модели с тремя сверточными слоями и нулевыми плотными слоями стабильно работают хорошо. Конкретное количество узлов на слой кажется менее значительным. Однако стоит отметить, что более плотные слои, такие как 512 или 256 узлов, могут дать еще лучшие результаты. Чтобы убедиться в этом, вы можете протестировать различные размеры плотного слоя.
Подводя итог, мы начали с изучения различных конфигураций моделей с помощью TensorBoard. Мы обнаружили, что модели с тремя сверточными слоями и без плотных слоев стабильно работают хорошо. Мы также определили, что количество узлов на слой может быть дополнительно оптимизировано. Тестируя различные размеры плотных слоев, мы потенциально можем еще больше повысить точность модели.
Имейте в виду, что это только отправная точка, и есть много других аспектов, которые вы можете настроить для оптимизации своих моделей. TensorBoard предоставляет ценный инструмент для визуализации и анализа этих вариантов модели, помогая вам принимать обоснованные решения по улучшению модели.
Как использовать обученную модель — основы глубокого обучения с помощью Python, TensorFlow и Keras, часть 6
Как использовать обученную модель — основы глубокого обучения с помощью Python, TensorFlow и Keras, часть 6
Привет всем и добро пожаловать в часть 6 серии руководств по глубокому обучению в Python с помощью TensorFlow и Keras!
В этом видео мы обсудим, как использовать нашу обученную модель для прогнозирования новых изображений. Многие люди спрашивали об этом, так как они успешно обучили и протестировали свои наборы данных, но не знают, как использовать модель для прогнозирования на внешних изображениях. Итак, давайте углубимся в это!
Во-первых, нам нужно импортировать необходимые библиотеки. Мы импортируем cv2 для обработки изображений и tensorflow как TF для работы с нашей моделью. Нам также понадобится список категорий, который содержит ярлыки классов «собака» и «кошка», которые мы использовали во время обучения.
Далее мы определим функцию с именем prepare, которая принимает путь к файлу в качестве параметра. Эта функция будет обрабатывать шаги предварительной обработки, необходимые для входного изображения. Мы изменим размер изображения до определенного размера и преобразуем его в оттенки серого. Затем изображение будет возвращено в виде измененного массива numpy.
После этого мы загрузим нашу обученную модель с помощью функции TF.keras.models.load_model(). Ранее мы сохранили нашу модель как «модель CNN 64 на 3», поэтому загрузим ее с тем же именем.
Теперь мы готовы делать прогнозы. Мы определим переменную с именем предсказание и назначим ей результат вызова model.predict() для нашего подготовленного изображения. Важно отметить, что метод predict() ожидает список в качестве входных данных, даже если мы предсказываем по одному изображению. Итак, нам нужно передать подготовленное изображение в виде списка.
Получив результат прогноза, мы можем его распечатать. Однако прогноз в настоящее время представлен в виде вложенного списка. Чтобы сделать его более читабельным, мы можем преобразовать значение предсказания в целое число и использовать его в качестве индекса для извлечения соответствующей метки класса из списка категорий.
Наконец, мы можем напечатать предсказанную метку класса, которая показывает, классифицируется ли изображение как собака или кошка.
В этом уроке мы использовали два внешних изображения для тестирования нашей модели: одно — собаки с конусом стыда, а другое — неизвестного существа. Эти изображения не были частью нашего обучающего набора данных, поэтому мы делаем прогнозы на невидимых данных.
Чтобы попробовать это с собственными изображениями собак и кошек, выполните шаги, описанные в коде. Имейте в виду, что точность может варьироваться, но в среднем она должна быть около 80%.
Это все на данный момент! Я хочу поблагодарить наших недавних спонсоров: Майкла, Ника, Родриго и Папасан Э. Мы очень ценим вашу поддержку. Если у вас есть какие-либо вопросы, комментарии или предложения для будущих руководств, оставьте их ниже. Я также открыт для идей по использованию рекуррентных нейронных сетей, поэтому, если у вас есть простой набор данных, дайте мне знать.
Увидимся в следующем уроке, где мы будем изучать рекуррентные нейронные сети. А пока удачного кодирования!
Рекуррентные нейронные сети (RNN) — глубокое обучение с Python, TensorFlow и Keras часть 7
Рекуррентные нейронные сети (RNN) — глубокое обучение с Python, TensorFlow и Keras часть 7
Всем привет и добро пожаловать в 7-ю часть серии руководств «Глубокое обучение с помощью Python TensorFlow в хаосе». В этой части мы сосредоточимся на рекуррентной нейронной сети (RNN). Цель RNN состоит в том, чтобы зафиксировать значимость и важность порядка данных. Это особенно актуально для данных временных рядов, где данные организованы во времени, и для обработки естественного языка, где порядок слов в предложении имеет значение.
Чтобы проиллюстрировать концепцию, давайте рассмотрим пример предложения: «Некоторые люди сделали нейронную сеть». Когда это предложение обрабатывается глубокой нейронной сетью, которая обычно токенизирует данные, разбивая их на отдельные слова, сеть может не уловить правильное значение. Например, предложение «Нейронная сеть создала некоторых людей» имеет совершенно другое значение. Это подчеркивает важность порядка слов в определении смысла предложения.
Теперь давайте углубимся в работу рекуррентной нейронной сети. Основным строительным блоком RNN является рекуррентная ячейка, которая часто реализуется с использованием ячейки долговременной кратковременной памяти (LSTM). Хотя существуют и другие варианты, такие как рекуррентная единица с закрытым входом (GRU), обычно используется ячейка LSTM. В RNN каждая ячейка принимает последовательные данные в качестве входных данных и выводит их на следующий уровень или следующую ячейку в рекуррентном слое.
Выход из клетки может быть направлен по-разному. Он может перейти на следующий уровень или в следующую ячейку однонаправленным или двунаправленным образом. В этом уроке мы сосредоточимся на базовой однонаправленной RNN. Чтобы проиллюстрировать это, представьте себе зеленую рамку, представляющую повторяющуюся ячейку. Данные из предыдущей ячейки поступают в текущую ячейку, которая выполняет такие операции, как забвение ненужной информации из предыдущего узла, включение новых входных данных и принятие решения о том, какую информацию выводить на следующий уровень или узел.
Чтобы лучше представить этот процесс, давайте рассмотрим конкретную ячейку в слое. Зеленое поле представляет текущую ячейку. Данные поступают из предыдущей ячейки, зацикливаются и поступают в ячейку LSTM. Внутри ячейки есть операции для забывания информации из предыдущего узла, включения новых входных данных и определения выходных данных, которые должны быть переданы следующему слою или узлу. Эти операции в совокупности позволяют ячейке LSTM сохранять важную информацию и передавать ее последующим уровням или узлам.
Реализация RNN может быть сложной, особенно при работе со скалярными значениями. Если вас интересует подробное объяснение того, как работают ячейки LSTM, я рекомендую ознакомиться с подробным руководством, в котором они подробно объясняются. Я включил ссылку на это руководство в текстовую версию руководства для вашего ознакомления.
Теперь давайте перейдем к созданию базовой рекуррентной нейронной сети. В этом руководстве мы начнем с простого примера с использованием набора данных M-NIST. В следующем уроке мы будем работать с более реалистичными данными временных рядов, уделяя особое внимание ценам на криптовалюту.
Для начала импортируем необходимые библиотеки. Мы будем импортировать TensorFlow как tf, модель Sequential из tensorflow.keras.models, слой Dense из tensorflow.keras.layers, а также ячейки Dropout и LSTM. Обратите внимание, что если вы используете версию TensorFlow для графического процессора, существует также оптимизированная ячейка LSTM, называемая ячейкой KU DNN LSTM. Однако в этом уроке мы будем придерживаться обычной ячейки LSTM. Если вы используете версию TensorFlow для ЦП, вычисления могут занять значительное время.
Далее нам нужно загрузить набор данных. В этом примере мы будем использовать набор данных M-NIST. Мы можем легко загрузить его с помощью функции tf.keras.datasets.mnist.load_data(), которая возвращает данные обучения и тестирования. Распаковываем данные в переменные: X_train, Y_train, X_test и Y_test.
Во-первых, давайте нормализуем входные данные, разделив значение каждого пикселя на 255. Это приведет к масштабированию значений пикселей в диапазоне от 0 до 1, что подходит для обучения нейронной сети. Мы можем добиться этого, разделив данные обучения и тестирования на 255.
X_train = X_train / 255.0 X_test = X_test / 255.0
Затем нам нужно преобразовать целевые метки в векторы с горячим кодированием. В наборе данных M-NIST метки представляют собой целые числа от 0 до 9, представляющие цифры. Горячее кодирование преобразует каждую метку в двоичный вектор длины 10, где индекс, соответствующий цифре, установлен в 1, а все остальные индексы установлены в 0. Мы можем использовать функцию to_categorical из tensorflow.keras.utils для выполнения одного -горячее кодирование.
Y_train = to_categorical(Y_train, num_classes=10)
Y_test = to_categorical(Y_test, num_classes=10)
Теперь давайте определим архитектуру нашей рекуррентной нейронной сети. Мы будем использовать модель Sequential из tensorflow.keras.models и добавим к ней слои.
from tensorflow.keras.layers import LSTM, Dense
model = Sequential()
model.add(LSTM(128, input_shape=(X_train.shape[1:]), activation='relu', return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(128, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))
Теперь давайте скомпилируем модель, указав функцию потерь, оптимизатор и метрику оценки.
model. compile (loss= 'categorical_crossentropy' , optimizer= 'adam' , metrics=[ 'accuracy' ])
Наконец, давайте обучим модель, используя данные обучения, и оценим ее на данных тестирования.
model.fit(X_train, Y_train, batch_size= 32 , epochs= 10 , validation_data=(X_test, Y_test))
Вот и все! Теперь вы построили рекуррентную нейронную сеть, используя ячейки LSTM для набора данных M-NIST. Вы можете экспериментировать с различными архитектурами, гиперпараметрами и наборами данных для дальнейшего изучения возможностей RNN.
RNN, предсказывающая криптовалюту - Глубокое обучение с Python, TensorFlow и Keras, часть 8
RNN, предсказывающая криптовалюту - Глубокое обучение с Python, TensorFlow и Keras, часть 8
Привет всем и добро пожаловать в еще одно обучающее видео по глубокому изучению Python. В этом и следующих видео мы обсудим, как применить рекуррентную нейронную сеть (RNN) к более реалистичному примеру работы с последовательными данными. В частности, мы будем работать с набором данных временных рядов, состоящим из цен и объемов криптовалют.
Прежде чем мы углубимся в детали, я хочу уточнить, что вы можете применять те же концепции к другим типам последовательных данных, таким как курсы акций или данные датчиков. Таким образом, даже если вы не интересуетесь финансами, вы все равно можете следовать и понимать концепции.
Цель этого руководства — использовать рекуррентную нейронную сеть для прогнозирования будущей цены криптовалюты на основе ее прошлой цены и объема. Мы сосредоточимся на четырех основных криптовалютах: Биткойн, Лайткойн, Эфириум и Биткойн Кэш. Идея состоит в том, чтобы взять данные о цене и объеме за последние 60 минут для каждой из этих криптовалют и использовать их в качестве входных данных для прогнозирования цены Litecoin, например, на три минуты вперед.
Этот тип проблемы прогнозирования также может применяться к другим областям, таким как прогнозирование сбоев сервера или трафика веб-сайта на основе данных о времени и использовании. Конечная цель состоит в том, чтобы либо предсказать классификацию (например, будет ли цена расти или падать), либо выполнить регрессию (например, предсказать фактическую цену или процентное изменение).
Работа с последовательными данными сопряжена с уникальными проблемами. Во-первых, нам нужно предварительно обработать данные и преобразовать их в последовательности, которые может обработать рекуррентная нейронная сеть. Кроме того, нам необходимо сбалансировать и нормализовать данные, учитывая, что цены и объемы разных криптовалют могут иметь разные масштабы. Масштабирование данных более сложное, чем в других областях, таких как данные изображения, где мы просто делим на 255.
Кроме того, оценка производительности модели с использованием данных вне выборки представляет собой другую проблему при работе с последовательными данными. Нам необходимо охватить несколько аспектов, включая подготовку данных, нормализацию и оценку.
Для начала я предоставил вам набор данных для загрузки. Ссылку на скачивание вы найдете в описании урока. После извлечения загруженного zip-файла вы найдете четыре файла, каждый из которых соответствует данным о цене и объеме одной криптовалюты.
Мы будем использовать библиотеку pandas в Python для чтения и управления набором данных. Если у вас не установлены панды, вы можете сделать это, запустив команду pip install pandas в терминале или в командной строке.
Далее мы прочитаем набор данных с помощью pandas и изучим данные. Мы сосредоточимся на столбцах «закрытия» цены и объема для каждой криптовалюты. Чтобы объединить данные из разных файлов, мы установим столбец «время» в качестве индекса для каждого кадра данных. Затем мы присоединимся к кадрам данных на основе их общего индекса.
Когда у нас есть объединенный фрейм данных, нам нужно определить некоторые параметры. К ним относятся длина последовательности (количество прошлых периодов для рассмотрения), будущий период (количество периодов в будущем для прогнозирования) и коэффициент прогнозирования (криптовалюта, которую мы хотим предсказать).
В нашем случае мы сосредоточимся на прогнозировании будущей цены Litecoin (LTC) на основе данных за последние 60 минут и будем прогнозировать на три минуты вперед. Мы также определим правило классификации, где мы классифицируем прогноз как повышение или снижение цены на основе текущих и будущих цен.
Выполнив эти начальные шаги, мы теперь готовы к предварительной обработке данных, созданию последовательностей и обучению рекуррентной нейронной сети. Мы рассмотрим эти темы в следующих видео, так что следите за обновлениями.
Если вы хотите продолжить, обязательно загрузите набор данных и настройте необходимые библиотеки. Вы можете найти полный код и инструкции в текстовой версии учебника, которая доступна в описании.
Нам есть что покрыть, поэтому давайте классифицируем это как 1, что указывает на рост цен. В противном случае, если будущая цена ниже текущей, мы классифицируем ее как 0, что указывает на падение цены. Это простое правило, которое мы используем для классификации, но вы можете экспериментировать с другими правилами или даже использовать регрессию для прогнозирования фактического изменения цены.
Теперь давайте создадим целевой столбец в нашем основном DataFrame. Мы будем использовать функцию сдвига от панд, чтобы сдвинуть значения столбца «LTCUSD_close» на будущий период. Это даст нам будущие цены, которые мы сравним с текущими ценами, чтобы определить классификацию. Мы назначим результат новому столбцу под названием «цель».
main_df[ 'target' ] = main_df[ 'LTCUSD_close' ].shift(-future_period)
main_df.dropna(inplace= True )
Далее создадим входные последовательности. Мы пройдемся по DataFrame и создадим последовательности длины sequence_length, состоящие из предыдущих цен и объемов биткойнов, лайткойнов, эфириума и биткойн-кэш. Мы будем хранить эти последовательности в списке под названием «последовательности».
for i in range(len(main_df) - sequence_length + 1):
sequence = main_df.iloc[i:i+sequence_length, 1:-1].values.flatten()
sequences.append(sequence)
Наконец, мы преобразуем последовательности и цели в пустые массивы для упрощения манипулирования и обучения.
sequences = np.array(sequences)
targets = np.array(main_df['target'])
Обратите внимание, что представленный здесь код является частичной реализацией и фокусируется на этапах предварительной обработки данных. Вам потребуется доработать архитектуру модели, обучить модель и оценить ее производительность. Кроме того, вам может потребоваться настроить гиперпараметры и поэкспериментировать с различными методами, чтобы повысить точность модели.
Не забудьте импортировать необходимые библиотеки, обработать отсутствующие данные, предварительно обработать функции (нормализация, масштабирование и т. д.) и разделить данные на наборы для обучения и тестирования перед обучением модели.
Я надеюсь, что это поможет вам понять процесс работы с последовательными данными и применения рекуррентных нейронных сетей для прогнозирования будущих цен. Удачи в вашем проекте глубокого обучения!