Kaggle gpu как подключить

Сохраняем производительность при участии в соревнованиях Kaggle

В последнее время во всем мире значительно возросла популярность технологий искусственного интеллекта и, соответственно, количество проводимых data science – соревнований. Также растет и число участников этих соревнований. В связи с этим, для лучшего распределения имеющихся ресурсов одной из ведущих площадок по организации подобных соревнований (Kaggle) было принято решение о введении лимита на использование участниками мощностей графических процессоров (англ. graphics processing unit, GPU) – не более 30 часов в неделю. При этом, если ноутбук использует 2 графических ядра одновременно, лимит сокращается в 2 раза быстрее.

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

Начну с официальных советов Kaggle по максимально эффективному использованию предоставляемых пользователям площадки графических процессоров:

• Подключайте графический процессор, только если планируете его использовать. Если ваш код не задействует возможности GPU (например, библиотеки TensorFlow, PyTorch и др.), выгоды от его подключения не будет, при этом выделенный лимит будет уменьшаться.
• Отслеживайте и управляйте использованием GPU. Kaggle имеет инструменты для мониторинга использования графического процессора, при помощи которых вы можете выявлять и отключать ненужные на текущий момент сеансы.
• Избегайте использования пакетных сессий (commit), чтобы сохранить или проверить свой прогресс. Пакетные сессии запускают и выполняют весь код последовательно, тратя на это время и лимит GPU. Эффективнее будет просто загрузить файл .ipynb из редактора.
• Отмените ненужные пакетные сессии. Одно и то же ядро может иметь несколько одновременных пакетных сессий, если вы повторно нажмете кнопку commit до завершения первой операции. Однако если ваш последний код был обновлен по сравнению с предыдущей версией, лучше отменить первый commit и оставить запущенным только второй.
• Остановите интерактивные сеансы до закрытия окна редактора. Интерактивные сеансы остаются активными до тех пор, пока не достигнут 60-минутного ограничения времени простоя. Если вы не остановите сеанс до закрытия окна редактора, выделенный лимит GPU будет уменьшаться, пока сеанс не будет прерван автоматически.
• Подумайте об использовании Kaggle-API, чтобы полностью избежать интерактивных сеансов.

На последнем пункте остановлюсь более подробно. Kaggle-API позволяет использовать и обрабатывать наборы данных Kaggle в сторонних приложениях. Например, в уже знакомом вам Google Colab. В отличие от Kaggle, Google Colab не имеет общего ограничения на длительность сеансов работы с GPU в неделю – лимит накладывается только в рамках одного сеанса (12 часов). При этом он на 3 часа превышает лимит, установленный для одного сеанса Kaggle.

Для доступа к API необходимо создать личный токен. Для этого необходимо зайти в меню Kaggle «My Account»:

перейти к разделу API и нажать кнопку «Create New API Token»:

В результате будет сформирован файл kaggle.json, который можно сохранить на свой компьютер. В дальнейшем он будет использоваться для доступа к наборам данных и соревнованиям Kaggle. Чтобы с токеном было проще работать, можно сохранить его на Google Drive. Это позволит не загружать его каждый раз с локального диска, а обращаться к токену напрямую. Чтобы получить доступ к API Kaggle в ноутбуке Google Colab необходимо выполнить следующую команду (восклицательный знак в начале строки кода позволяет выполнить команду операционной системы Linux прямо из ноутбука Colab):

!pip install kaggle

Затем перенесем в ноутбук токен, сформированный на предыдущем шаге (я заранее скопировал его в корневую папку Google Drive):

!mkdir -p ~/.kaggle !cp '/content/drive/My Drive/kaggle.json' ~/.kaggle

Теперь можно использовать API Kaggle из Google Colab. Инструмент командной строки поддерживает следующие команды ( подробнее со списком команд и примерами их использования можно ознакомиться на GitHub по ссылке https://github.com/Kaggle/kaggle-api):

Например, для получения списка датасетов, имеющихся на платформе Kaggle, нужно выполнить команду: !kaggle datasets list. А для загрузки данных по какому-либо соревнованию – команду: !kaggle competitions download -c liverpool-ion-switching, где liverpool-ion-switching – название соревнования.

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

Как импортировать наборы данных Kaggle в Google Colab?

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

В этой статье будет показано, как импортировать наборы данных из Kaggle непосредственно в блокноты Google Colab.

Шаг 1: Выбор любого набора данных из Kaggle

Первый и самый важный шаг — выбор набора данных из Kaggle. Можно выбирать датасеты из конкурсов. Для этой статьи было выбрано два набора данных: один случайный, другой — из действующего конкурса.

Шаг 2: Загрузка учетных данных API

Чтобы загрузить данные из Kaggle, необходимо пройти аутентификацию в сервисах Kaggle. Для этого понадобится API-токен. Его можно сгенерировать в разделе профиля учетной записи пользователя Kaggle.

Сначала перейдите в свой профиль Kaggle:

Теперь откройте вкладку “Account” (“Аккаунт”) и опуститесь до раздела “API” (скриншот из профиля Kaggle).

Будет загружен файл с именем “kaggle.json”, который содержит имя пользователя и ключ API.

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

Шаг 3: Настройка блокнота Colab

Запустите блокнот Google Colab и подключите его к облачному экземпляру (по сути, это запуск интерфейса блокнота). Затем загрузите файл “kaggle.json”, скачанный с Kaggle.

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

Примечание: Здесь будут выполнятся команды на Linux и команды установки, начинающиеся с “!”. Поскольку экземпляры Colab работают на базе Linux, можете запускать все команды Linux в ячейках кода.

Следуйте этим командам:

1. Установить библиотеку Kaggle:

! pip install kaggle

2. Создать каталог с именем “.kaggle”:

! mkdir ~/.kaggle

3. Скопировать файл “kaggle.json” в созданный каталог:

! cp kaggle.json ~/.kaggle/

4. Назначить необходимое разрешение для этого файла:

! chmod 600 ~/.kaggle/kaggle.json

Теперь блокнот Golab готов к загрузке наборов данных из Kaggle.

Это все команды, необходимые для настройки блокнота Golab

Шаг 4: Загрузка наборов данных

На Kaggle размещается два типа наборов данных: Competitions (Конкурсы) и Datasets (Датасеты). Процедуры загрузки различных типов данных отличаются незначительными нюансами.

Загрузка набора данных Competitions:

! kaggle competitions download

Здесь “name of the competition” — не название жирным шрифтом, отображаемое на заднем плане. Это фрагмент ссылки на competition, который следует после “/c/”. Вот пример ссылки:

“google-smartphone-decimeter-challenge” — имя competition (конкурса), которое нужно передать команде Kaggle. Эта команда загрузит данные в выделенное хранилище в экземпляре:

Загрузка Datasets:

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

! kaggle datasets download

Здесь “name of the dataset” — это “user-name/dataset-name” (“имя пользователя/имя набора данных”). Вам нужно просто скопировать текст после “www.kaggle.com/»:

В нашем случае получится: “arenagrenade/the-complete-pokemon-images-data-set”.

При получении набора данных с zip-расширением используйте команду unzip в Linux для извлечения данных:

! unzip

Бонусные лайфхаки

Лайфхак 1: Загрузка конкретных файлов

Вы уже знаете, как загружать наборы данных из Kaggle в Google Colab. Если же вам нужно загрузить определенный файл, используйте флаг “-f”, за которым следует имя файла. Так вы загрузите только этот конкретный файл. Флаг “-f” работает как для команды competitions, так и для команды datasets.

! kaggle competitions download google-smartphone-decimeter-challenge -f baseline_locations_train.csv

Можете ознакомиться с официальной документацией Kaggle API для получения дополнительной информации о возможностях и командах.

Лайфхак 2: Загрузка учетных данных Kaggle из Google Drive

В шаге 3 при настройке блокнота вы загрузили файл “kaggle.json”. Однако файлы, загруженные в хранилище, предоставленное во время настройки блокнота, не сохраняются после завершения работы блокнота.

Поэтому вам нужно загружать файл JSON каждый раз, когда блокнот перезагружается или перезапускается. Чтобы избежать этой ручной работы, выполните следующие действия:

1. Загрузите файл “kaggle.json” на свой Google Drive. Для упрощения задачи стоит загрузить его в корневую папку, а не в какую-либо подструктуру папок.

2. Подключите Google Drive к блокноту:

3. Дайте команды для установки библиотеки Kaggle и создания каталога с именем “.kaggle” (они остаются прежними):

! pip install kaggle! mkdir ~/.kaggle

4. Скопируйте файл “kaggle.json” из подключенного Google Drive в хранилище текущего экземпляра. Google Drive подключается по пути “./content/drive/MyDrive”. Просто выполните команду copy, используемую в Linux:

!cp /content/drive/MyDrive/kaggle.json ~/.kaggle/kaggle.json

Теперь можно использовать команду для Kaggle competitions и datasets для загрузки наборов данных. Преимущество этого метода в том, что не нужно загружать файл учетных данных при каждом повторном запуске блокнота.

Преимущества использования Google Colab

Google Colab — отличный инструмент для различных исследований данных. Бесплатная поддержка GPU — одно из главных преимуществ Colab. На первых порах начинающие специалисты по обработке данных испытывают нехватку вычислительных ресурсов, поэтому использование Google Colab решает их аппаратные проблемы. Поскольку ноутбуки Colab работают на Linux, можно выполнять все стандартные команды Linux и взаимодействовать с ядром.

Для практикования с наборами данных достаточно оперативной памяти и дискового пространства. Если же ваши исследования требуют дополнительных вычислительных мощностей, можете перейти на “Colab pro”.

• Управление файлами в Google Colab
• Как стать специалистом по обработке данных: 5 советов
• 10 бесплатных ресурсов для обучения обработке естественного языка

Знакомство с Kaggle: изучаем науку о данных на практике

Теорию лучше совмещать с практикой. Если вы изучаете Data Science, то вам стоит попробовать себя в соревнованиях Kaggle.

Рассказывает Уильям Коерсен, эксперт по аналитическим данным

На данный момент этот блок не поддерживается, но мы не забыли о нём! Наша команда уже занята его разработкой, он будет доступен в ближайшее время.

Можно найти множество обучающих ресурсов по анализу данных — от Datacamp до Udacity, все они позволяют изучить науку о данных. Но если вы из тех, кто любит учиться через практику, то Kaggle, возможно, окажется лучшей платформой, чтобы улучшить ваши навыки с помощью практических проектов в области научных исследований.

Сначала Kaggle, который позиционирует себя как «ваш дом для науки о данных», был местом для соревнований по машинному обучению, но сейчас там можно найти и ресурсы по науке о данных. Стоит упомянуть несколько главных особенностей Kaggle:

• Datasets (наборы данных): множество наборов данных различных типов и размеров, которые можно бесплатно загрузить. Здесь можно найти интересные данные для изучения или тестирования своих навыков моделирования.
• Machine Learning Competitions (соревнования по машинному обучению): когда-то были сердцем Kaggle, такие тесты на моделирование — лучший способ изучить новые виды машинного обучения и отточить ваши способности с помощью интересных проблем, основанных на реальных данных.
• Learn (изучение): серия обучающих материалов по изучению данных, охватывающих SQL и глубокое обучение (Deep Learning), которые подаются в Jupyter Notebooks.
• Discussion (обсуждения): место, где можно задать свои вопросы и получить советы от тысяч экспертов по аналитическим данным (data scientist) в сообществе Kaggle.
• Kernels (ядра): онлайн-среда для программирования, которая работает на серверах Kaggle. В ней можно писать Python/R-скрипты и работать в Jupyter Notebooks. Такие ядра абсолютно бесплатны (можно даже добавить GPU) и идеальны для тестирования: не нужно настраивать среду у себя на компьютере. Их можно использовать для анализа любого набора данных, соревнований по машинному обучению или выполнения заданий из раздела «Обучение». Можно скопировать или изменить уже существующее ядро другого пользователя, а также поделиться своим, чтобы его смогли оценить остальные.

Главные аспекты Kaggle

В целом Kaggle — отличное место для обучения: либо через более традиционные учебные задания, либо через соревнования со страницы Competitions. Чтобы узнать о новейшем методе машинного обучения, можно прочитать книгу или посмотреть на Kaggle, как люди используют этот метод на практике. Второе мне кажется гораздо более приятным и эффективным. Более того, сообщество чрезвычайно общительное и всегда готово ответить на вопросы или дать обратную связь по проекту.

В этой статье мы разберёмся, как начать работу с конкурсом машинного обучения в Kaggle: Home Credit Default Risk problem. Это довольно простое соревнование с набором данных разумного размера (а так бывает не всегда), что означает, что мы сможем полностью выполнить задание на ядре от Kaggle. Это значительно снижает барьер для входа, потому что вам не нужно беспокоиться о каком-либо программном обеспечении на вашем компьютере и загружать данные. Если у вас есть учётная запись Kaggle и доступ к интернету, вы сможете подключиться к ядру и запустить код.

Я планирую провести весь конкурс на Kaggle, и ядро ​​(Python Jupyter Notebook) для этой статьи можно посмотреть здесь. Чтобы получить от этой статьи максимум, скопируйте ядро, создав учётную запись Kaggle, а затем нажмите голубую кнопку с надписью «Fork Notebook». Это откроет место для редактирования и работы в среде ядра.

Описание соревнования

Home Credit Default Risk competition — это стандартная контролируемая задача машинного обучения, которая с помощью данных по кредитной истории прогнозирует, погасит ли заёмщик кредит. Во время обучения мы предоставляем нашу модель со свойствами — переменными, описывающими заявку на получение кредита, и ярлыком — 0, если кредит был погашен, и 1, если кредит не был погашен — и модель учится сопоставлять свойства и ярлыки. Затем во время тестирования мы подаём в модель свойства новой серии заявлений на кредит и просим её предсказать ярлык.

Home Credit, являющийся организатором соревнования, — это финансовый провайдер, который специализируется на финансовых услугах. Для финансового бизнеса предсказать, погасит ли заёмщик кредит, жизненно важно. Home Credit запустил этот конкурс в надежде, что сообщество Kaggle разработает эффективный алгоритм для решения этой задачи. Этот конкурс следует общей идее большинства соревнований в Kaggle: у компании есть данные и проблема, которую необходимо решить, и вместо того, чтобы нанять в штат экспертов по аналитическим данным для создания модели, они предлагают относительно скромный приз, чтобы подвигнуть на решение проблемы весь мир. Сообщество, состоящее из тысяч квалифицированных экспертов по аналитическим данным (Kagglers), работает над проблемой практически бесплатно, чтобы найти наилучшее решение.

Среда Kaggle для соревнований

На картинке ниже можно увидеть, что находится на домашней странице соревнований.

Краткое описание вкладок:

• Overview: краткое описание проблемы, метрики, оценки, призы и временная шкала.
• Data: все данные, необходимые для участия в конкурсе, другие данные не допускаются. Можно загрузить всю информацию к себе на компьютер, но мы этого делать не будем, так как будем использовать ядро Kaggle, к которому можно просто подключить данные.
• Kernels: предыдущие работы, сделанные вами или другими участниками. Для соревнования это наиболее важный ресурс. Вы можете изучить другие скрипты и notebooks, а потом скопировать (называется «Forking»), чтобы изменить их и запустить.
• Discussion: ещё одна полезная вкладка, где можно найти обсуждения, в которых участвуют как организаторы соревнования, так и участники. Здесь можно задать уточняющие вопросы или почерпнуть новую информацию из ответов другим участникам.
• Leaderboard: можно посмотреть, кто в топе, и ваш рейтинг.
• Rules: правила — не очень интересно, но их стоит знать.
• Team: здесь можно управлять членами команды, если вы решите создать свою.
• My Submissions: можно посмотреть ваши предыдущие материалы и выбрать финальный вариант, который будет участвовать в соревновании.

Почему важно учиться у других?

Соревнования Kaggle по машинному обучению, хоть они и называются так, стоит называть скорее «совместными проектами», потому что главной целью является не столько выиграть, сколько попрактиковаться и поучиться у друга-эксперта. Как только вы осознаете, что здесь главное — не превзойти других, а улучшить свои навыки, вы получите от соревнований максимальную пользу. Когда вы регистрируетесь на Kaggle, вы получаете не только доступ ко всем ресурсам, но и возможность стать частью сообщества экспертов по аналитическим данным.

Воспользуйтесь преимуществом их опыта и постарайтесь быть активным участником сообщества! Можно как поделиться своими наработками ядра, так и задать вопрос в ветке обсуждений. Конечно, перспектива выложить свою работу в общий доступ пугает, но это позволит получить отзыв на свою работу и исправить существующие ошибки, а также не совершать их в будущем. Все начинают, как новички, а сообщество экспертов по аналитическим данным очень поддерживает своих на всех уровнях подготовки.
Создание новых обсуждений и использование чужого ядра не только не возбраняется, но и поощряется! В школе это посчитали бы жульничеством, а в реальном мире это чрезвычайно важный навык командной работы.

Лучший способ участия в соревновании — найти чужое ядро с хорошим результатом в таблице лидеров, скопировать его и попытаться улучшить результат. Потом поделиться своим ядром с сообществом, чтобы другие могли использовать его. Экспертное сообщество по аналитическим данным стоит не на плечах атлантов, а на спинах тысяч людей, которые поделились своей работой с другими (извините за философствование, но именно по этим причинам я так люблю науку о данных!).

Работа в первом Notebook

Теперь, когда вы получили базовое представление о том, как работает Kaggle, и вдохновились тем, сколько преимуществ можно получить от соревнований, настало время начать. Здесь я кратко рассказываю о Python Jupyter Notebook, который я собрал для Home Credit Default Risk problem. Но чтобы получить представление, лучше всего будет скопировать его и запустить самостоятельно (вам не придётся что-то скачивать или настраивать, так что очень рекомендую это сделать).

Когда вы откроете notebook в ядре, вы увидите следующее:

Окружения ядра для Notebook

Перед вами стандартный Jupyter Notebook с немного отличающимся внешним видом. Вы можете писать код на Python или обычный текст (используя синтаксис Markdown) точно так же, как и в Jupyter, а потом запускать код на облачном сервере Kaggle. Однако ядра Kaggle имеют некоторые отличительные особенности, недоступные в Jupyter Notebook. Нажмите стрелку влево в правом верхнем углу, которая откроет три вкладки (если вы в режиме полноэкранного просмотра, эти вкладки уже могут быть открыты).

Во вкладке Data отображаются наборы данных, к которым наше ядро подключено. В этом случае у нас все данные с соревнования, но мы также можем подключить другие данные с Kaggle или загрузить свои. Файлы с данными лежат в директории ../input/.

Код для доступа к ним:

import os # List data files that are connected to the kernel os.listdir('../input/') 

Вкладка Settings позволяет нам контролировать различные технические аспекты ядра. Мы можем добавить GPU, изменить видимость или установить пакет Python, которого ещё нет в окружении.

Последняя вкладка Versions позволяет посмотреть предыдущие коммиты. Мы можем смотреть изменения в коде, просматривать лог-файлы запуска, видеть notebook, сгенерированный при запуске, и загружать выходные данные прогона.

Чтобы запустить весь notebook и записать новую версию, нужно нажать голубую кнопку Commit & Run в правом верхнем углу ядра. Это действие выполнит весь код и сохранит любые файлы, которые будут созданы во время запуска. Закоммитив notebook, мы сможем получить доступ к любым прогнозам, сделанным нашей моделью, и подать их на оценивание.

Вводный Notebook Outline

Первый notebook предназначен для ознакомления с проблемой. Нужно начинать с основ: убедиться, что понятны используемые данные и задание. Для этой проблемы есть один главный тренировочный набор данных с уже расставленными метками и 6 дополнительных файлов. В первом notebook мы используем только главный файл, который принесёт достойный результат, но дальнейшая работа подразумевает, что мы будем использовать все файлы с данными, чтобы быть конкурентоспособными.

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

Как только мы разобрались с данными и проблемой, мы можем начать структурировать задачи машинного обучения. Это подразумевает работу с категориальными переменными (через one-hot encoding), заполнение пропущенных значений (imputation) и масштабирование переменных в диапазоне. Мы можем проводить анализ исследовательских данных, например поиск закономерности с ярлыком, и отрисовывать такие закономерности.

На данный момент этот блок не поддерживается, но мы не забыли о нём! Наша команда уже занята его разработкой, он будет доступен в ближайшее время.

Позже мы сможем использовать эти закономерности для моделирования решений, например, какие переменные использовать (смотрите notebook для реализации).

На данный момент этот блок не поддерживается, но мы не забыли о нём! Наша команда уже занята его разработкой, он будет доступен в ближайшее время.

Разумеется никакой анализ исследовательских данных не будет полным без моего любимого Pairs Plot.

На данный момент этот блок не поддерживается, но мы не забыли о нём! Наша команда уже занята его разработкой, он будет доступен в ближайшее время.

После тщательного изучения данных и обеспечения приемлемости для машинного обучения, мы переходим к созданию базовых моделей. Однако, прежде чем мы полностью перейдём к этапу моделирования, важно понять показатель производительности для соревнований. В соревновании Kaggle всё сводится к одному числу — метрике по тестовым данным.

Хотя интуитивно кажется, что нужно использовать точность для задачи бинарной классификации, это будет плохим решением, потому что мы имеем дело с проблемой несбалансированного класса. Вместо точности, решения оцениваются с помощью ROC AUC (Receiver Operating Characteristic curve Area Under the Curve). Я позволю вам самостоятельно разобраться в этом или почитать объяснение в notebook. Просто знайте, что чем выше результат, тем лучше. Чтобы вести подсчёты с помощью ROC AUC, нам нужно делать прогнозы в терминах вероятностей, а не бинарные — 0 или 1. ROC показывает истинную положительную оценку по сравнению с ложно положительной оценкой, как функцию порога, согласно которому мы классифицируем экземпляр как положительный.

Обычно нам нравится делать наивное базовое предсказание, но в этом случае мы уже знаем, что случайные догадки по задаче будут равны 0,5 по ROC AUC. Поэтому для нашей модели мы будем использовать несколько более сложный метод — логистическую регрессию. Это популярный простой алгоритм для задач бинарной классификации, который поможет установить низкий порог для прохождения будущими моделями.

После применения логистической регрессии, мы можем сохранить результат в csv-файл для отправки. Когда notebook закоммичен, любые выходные файлы появятся на вкладке Output в Versions.

С этой вкладки мы можем загрузить получившиеся файлы на компьютер, а потом выгрузить их для участия в соревновании. В этом notebook мы сделали четыре разные модели. Их оценки не приближают нас к вершине таблицы лидеров, но оставляют место для множества улучшений в будущем! Также мы получили представление о производительности, которую мы можем ожидать, используя всего лишь один источник с данными.

Неудивительно, что экстраординарный Gradient Boosting Machine (использовалась библиотека LightGBM) отработал лучше всего. Эта модель побеждает практически в каждом структурированном Kaggle соревновании (где данные представлены в табличном формате) и нам, вероятно, придётся использовать какую-то форму этой модели, если мы хотим достойно конкурировать с другими участниками.

Вывод

В этой статье я хотел рассказать, как начать участвовать в соревнованиях Kaggle. Цели победить я не ставил, скорее хотелось показать вам, как подойти к соревнованию по машинному обучению, и продемонстрировать несколько решений.

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

Остаётся много работы, но, к счастью, нам больше не нужно делать её в одиночку. Я надеюсь, эта статья и notebook kernel придали вам уверенности, чтобы начать участвовать в соревнованиях Kaggle или заняться любым научным проектом.

Введение

Вычисления на графических процессорах становятся всё более и более важными.

1. Количество данных во всём мире удваивается каждый год.
2. Приходит квантовая реальность. Закон Мура перестаёт работать.

Кроме того, растёт число онлайн-платформ анализа данных с поддержкой GPU. В их число входят:

• Kaggle
• Google Colaboratory
• Microsoft Azure
• AWS

В этой статье я познакомлю вас с RAPIDS — открытыми библиотеками NVIDIA для Python, а затем покажу, как она работает, ускоряя анализ данных в 50 раз. Код из статьи доступен на Github и Google Colaboratory.

RAPIDS

Для работы с большими данными в последние несколько дней было предложено множество решений: MapReduce , Hadoop , Spark . RAPIDS созданы как следующий шаг эволюции обработки данных. Благодаря формату Apache Arrow RAPIDS в оперативной памяти могут быть в 50 раз быстрее, чем Spark . Доступно масштабирование от однопроцессорной до мультипроцессорной архитектуры. RAPIDS имеет интерфейс, схожий с популярными Pandas и Sklearn .

Все пакеты RAPIDS бесплатны и доступны в Anaconda, Docker, Google Colaboratory и других облачных платформах. Структура базируется на различных библиотеках для ускорения всех задач анализа данных от начала до конца:

• cuDF для задач предварительной обработки данных, как Pandas .
• cuML для создания моделей ML, как Sklearn .
• cuGraph для выполнения задач с графами.

RAPIDS имеет дополнительную интеграцию с PyTorch и Chainer для глубокого обучения, Kepler GL для визуализации и Dask для распределённых вычислений.

Демонстрация

Я покажу, как RAPIDS ускоряет анализ данных более чем в 5 раз в сравнении со Sklearn . Напомню: весь код доступен в Google Colaboratory. Протестируйте его сами!

Чтобы использовать библиотеки, мы сначала должны подключить к нашему Google Colaboratory поддержку GPU. Это будет Tesla T4. Затем устанавливаем зависимости. На моём GC есть инструкция.

Предобработка

Как только всё установлено, импортируем необходимые библиотеки:

import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn import preprocessing
from xgboost import XGBClassifier
import cudf
import xgboost as xgb
from sklearn.metrics import accuracy_score

Сравниваем Sklearn и RAPIDS . В нашем случае я решил использовать Pandas для предварительной обработки данных и для Sklearn , и для RAPID . На GC доступна предобработка с cuDF вместо Pandas .

Я решил сгенерировать простой набор данных, используя распределение Гаусса. Он содержит три признака и две метки, 0/1 . Величины и стандартные отклонения подобраны так, чтобы упростить решение проблемы классификации. Данные разделимы линейно:

# Создаём линейно разделяемый набор с гауссовым распределением.
# Первая его половина с меткой 0, вторая с меткой 1.
# Принципы генерации данных схожи, а метки различны.
# Поэтому классифицировать их легко.dataset_len = 8000000
dlen = int(dataset_len/2)
X_11 = pd.Series(np.random.normal(2,2,dlen))
X_12 = pd.Series(np.random.normal(9,2,dlen))
X_1 = pd.concat([X_11, X_12]).reset_index(drop=True)
X_21 = pd.Series(np.random.normal(1,3,dlen))
X_22 = pd.Series(np.random.normal(7,3,dlen))
X_2 = pd.concat([X_21, X_22]).reset_index(drop=True)
X_31 = pd.Series(np.random.normal(3,1,dlen))
X_32 = pd.Series(np.random.normal(3,4,dlen))
X_3 = pd.concat([X_31, X_32]).reset_index(drop=True)
Y = pd.Series(np.repeat([0,1],dlen))
df = pd.concat([X_1, X_2, X_3, Y], axis=1)
df.columns = ['X1', 'X2', 'X3', 'Y']
df.head()

Набор сгенерировался. Делим его признаки и метки по осям и определяем функцию предварительной обработки:

X = df.drop(['Y'], axis = 1).values
y = df['Y']

def preproces(df, X, y, train_size = 0.80): 
# label_encoder object knows how to understand word labels. 
label_encoder = preprocessing.LabelEncoder() 
 
# Преобразуем метки 
y = label_encoder.fit_transform(y) 
 
# identify shape and indices 
num_rows, num_columns = df.shape 
delim_index = int(num_rows * train_size)
 
# Делим данные на тестовые и тренировочные 
X_train, y_train = X[:delim_index, :], y[:delim_index] 
X_test, y_test = X[delim_index:, :], y[delim_index:]
 
# Проверяем размерность. 
print('X_train dimensions: ', X_train.shape, 'y_train: ', y_train.shape) 
print('X_test dimensions:', X_test.shape, 'y_validation: ', y_test.shape)
 
# Размерность в процентах. 
total = X_train.shape[0] + X_test.shape[0] 
print('X_train Percentage:', (X_train.shape[0]/total)*100, '%') 
print('X_test Percentage:', (X_test.shape[0]/total)*100, '%') 
 
return X_train, y_train, X_test, y_test

X_train, y_train, X_test, y_test = preproces(df, X, y)

У нас есть тестовые и тренировочные данные. Наконец, мы готовы обучить модель. Используем XGBoost как классификатор.

RAPIDS

Преобразуем наборы в матрицы для XGBoost :

dtrain = xgb.DMatrix(X_train, label=y_train)
dtest = xgb.DMatrix(X_test, label=y_test)

%%time

# Начальные параметры XGBoost.
params = <>

clf = xgb.train(params, dtrain)

Вывод ниже. С XGBoost из RAPIDS мы тренировали модель менее двух минут:

CPU times: user 1min 54s, sys: 307 ms, total: 1min 54s
Wall time: 1min 54s

Кроме того, RAPIDS предоставляет удобный метод importance для отрисовки важности данных на диаграмме:

xgb.plot_importance(clf)

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

Наконец, выясним точность классификатора:

XGB accuracy using RAPIDS: 98.0 %

Повторим это со Sklearn :

%%time

model = XGBClassifier()
model.fit(X_train, y_train)

11 минут. RAPIDS быстрее Sklearn в 5,8 раз: 662/114 . Используя cuDF вместо Pandas , мы можем добиться результатов ещё быстрее.

CPU times: user 11min 2s, sys: 594 ms, total: 11min 3s
Wall time: 11min 2s

sk_pred = model.predict(X_test)
sk_pred = np.round(sk_pred)
sk_acc = round(accuracy_score(y_test, sk_pred), 2)
print("XGB accuracy using Sklearn:", sk_acc*100, '%')

Точность та же: 98,0% . Это значит, что RAPIDS работает быстрее и без потери точности.

XGB accuracy using Sklearn: 98.0 %

Заключение

Выше мы видим: используя RAPIDS , можно добиться стабильного уменьшения времени работы с данными (в случае очень больших данных с дней до часов и с часов до минут). Наконец, RAPIDS предоставляет ценную документацию и примеры. Посмотрите здесь и здесь, если хотите узнать больше. Также я создал два других примера: cuGraph и интеграция с Dask , здесь и здесь.

• Машинное обучение. С чего начать? Часть 1
• Алгоритмы машинного обучения простым языком. Часть 1
• Руководство по машинному обучению для новичков