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

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

Для решения нашей задачи снова используем язык программирования python и среду разработки Jupyternotebook на платформе GoogleColab.

В работе понадобятся следующие библиотеки:

• scikit-learn свободно распространяемая библиотека на python, содержащая реализации различных методов машинного обучения;

• nltk пакетбиблиотекдля символьной и статистическойобработки естественного языка;

• matplotlib библиотека, содержащая набор инструментов для визуализации данных, понадобится для отображения облака слов.

Подробности реализации

Датасет сохранен в файле формата csv и содержит чуть более 8 тысяч записей. Для работы с ним будем использовать библиотеку pandas загружаем данные в память при помощи метода read_csv и отображаем на экране несколько первых строк:

import pandas as pddf_habr = pd.read_csv(habrParse.csv)df_habr.head()

Набор данных представляет собой таблицу, в первой колонке которой хранится текст статьи, во второй присвоенная категория (класс):

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

# Получение текстовой строки из списка словdef str_corpus(corpus):    str_corpus = ''    for i in corpus:        str_corpus += ' ' + i    str_corpus = str_corpus.strip()    return str_corpus# Получение списка всех слов в корпусеdef get_corpus(data):    corpus = []    for phrase in data:        for word in phrase.split():            corpus.append(word)    return corpus# Получение облака словdef get_wordCloud(corpus):    wordCloud = WordCloud(background_color='white',                              stopwords=STOPWORDS,                              width=3000,                              height=2500,                              max_words=200,                              random_state=42                         ).generate(str_corpus(corpus))    return wordCloudcorpus = get_corpus(df_train['text'].values)procWordCloud = get_wordCloud(corpus)fig = plt.figure(figsize=(20, 8))plt.subplot(1, 2, 1)plt.imshow(procWordCloud)plt.axis('off')plt.subplot(1, 2, 1)

Для необработанного набора данных облако слов содержит 243024 уникальных слова и выглядит так:

Попробуем очистить данные:

import nltknltk.download("stopwords")from nltk.corpus import stopwordsfrom string import punctuationrussian_stopwords = stopwords.words("russian")# Удаление знаков пунктуации из текстаdef remove_punct(text):    table = {33: ' ', 34: ' ', 35: ' ', 36: ' ', 37: ' ', 38: ' ', 39: ' ', 40: ' ', 41: ' ', 42: ' ', 43: ' ', 44: ' ', 45: ' ', 46: ' ', 47: ' ', 58: ' ', 59: ' ', 60: ' ', 61: ' ', 62: ' ', 63: ' ', 64: ' ', 91: ' ', 92: ' ', 93: ' ', 94: ' ', 95: ' ', 96: ' ', 123: ' ', 124: ' ', 125: ' ', 126: ' '}    return text.translate(table)habrParse_df['Post_clean'] = habrParse_df['Post'].map(lambda x: x.lower())habrParse_df['Post_clean'] = habrParse_df['Post_clean'].map(lambda x: remove_punct(x))habrParse_df['Post_clean'] = habrParse_df['Post_clean'].map(lambda x: x.split(' '))habrParse_df['Post_clean'] = habrParse_df['Post_clean'].map(lambda x: [token for token in x if token not in russian_stopwords\                                                                  and token != " " \                                                                  and token.strip() not in punctuation])habrParse_df['Post_clean'] = habrParse_df['Post_clean'].map(lambda x: ' '.join(x))

После небольшой очистки текстов от стоп-слов и знаков пунктуации количество уникальных слов снизилось до 142253, а облако слов стало более осмысленным:

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

Посмотрим статистику по классам:

Видно, что некоторые классы представлены только одним элементом, а класс Чулан составляет более 65% датасета. Для того чтобы работать с более или менее сбалансированным датасетом, выберем тексты только четырех классов:

df_habr_clean = df_habr.loc[df_habr['hubs'].isin(['IT-компании', 'Habr', 'Управление медиа', 'Я пиарюсь'])]

Разделим датасет на тренировочную, тестовую и валидационную части:

from sklearn.model_selection import train_test_splitX_train, X_valid, y_train, y_valid = train_test_split(df_habr_clean ['Post_clean'], df_habr_clean ['hubs'], test_size=0.1, random_state=42)X_train, X_test, y_train, y_test = train_test_split(X_train, y_train, test_size=0.2, random_state=42)

Получили следующее соотношение выборок:X_train 1136 элементов,X_test 283 элемента,X_valid 158 элементов

Для дальнейшей работы понадобится импортировать несколько модулей из библиотеки scikit-learn:

from sklearn.pipeline import Pipeline# pipeline позволяет объединить в один блок трансформер и модель, что упрощает написание кода и улучшает его читаемостьfrom sklearn.feature_extraction.text import TfidfVectorizer# TfidfVectorizer преобразует тексты в числовые вектора, отражающие важность использования каждого слова из некоторого набора слов (количество слов набора определяет размерность вектора) в каждом текстеfrom sklearn.linear_model import SGDClassifierfrom sklearn.neighbors import KNeighborsClassifier# линейный классификатор и классификатор методом ближайших соседейfrom sklearn import metrics# набор метрик для оценки качества моделиfrom sklearn.model_selection import GridSearchCV# модуль поиска по сетке параметров

Сначала создадим 2 классификатора (чтобы можно было в дальнейшем сравнить качество получившихся моделей) и обучим их на тестовых данных:

sgd_ppl_clf = Pipeline([    ('tfidf', TfidfVectorizer()),    ('sgd_clf', SGDClassifier(random_state=42))])knb_ppl_clf = Pipeline([    ('tfidf', TfidfVectorizer()),    ('knb_clf', KNeighborsClassifier(n_neighbors=10))])sgd_ppl_clf.fit(X_train, y_train)knb_ppl_clf.fit(X_train, y_train)

Предскажем получившимися моделями класс текстов в тестовой выборке и сравним метрики:

predicted_sgd = sgd_ppl_clf.predict(X_test)print(metrics.classification_report(predicted_sgd, y_test))

predicted_sgd = knb_ppl_clf.predict(X_test)print(metrics.classification_report(predicted_sgd, y_test))

В связи с тем, что датасет не сбалансирован, метрику accuracy (доля верных ответов) использовать нельзя, так как это приведет к завышенной оценке качества работы классификатора. В данном случае самое правильное считать сразу несколько метрик, устойчивых к распределению классов (в данном случае, это точность, полнота и f-мера) и смотреть на них все. Однако часто бывает удобно получить не большой набор цифр, а одно число, по которому можно понять, насколько хорошо модель работает. В нашей задаче лучше всего подходит macro-avg (сначала подсчитывается каждая метрика по каждому классу, а потом усредняется). Macro-avg более устойчива к скошенным распределениям классов.

Линейный классификатор показал лучший результат на тестовых данных (0,77 против 0,72 у классификатора методом ближайших соседей), поэтому для дальнейшей настройки модели будем использовать его.

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

Попробуем улучшить нашу модель, используя различные параметры. Следует иметь в виду, что для доступа к параметрам объекта pipeline необходимо указывать их в виденазвание объекта__название параметра:

Обучим модель, используя предложенные параметры (часть из них получила значение по умолчанию, поэтому их указывать не обязательно), и оценим ее качество на тестовых данных:

sgd_ppl_clf = Pipeline([    ('tfidf', TfidfVectorizer(ngram_range=(1, 2))),    ('sgd_clf', SGDClassifier(penalty='elasticnet', class_weight='balanced', random_state=42))])sgd_ppl_clf.fit(X_train, y_train)predicted_sgd = sgd_ppl_clf.predict(X_test)print(metrics.classification_report(predicted_sgd, y_test))

Значение целевой метрики выросло.

predicted_sgd_val = sgd_ppl_clf.predict(X_valid)print(metrics.classification_report(predicted_sgd_val, y_valid))

На валидационной выборке качество также выросло (0,8 против 0,76 с использованием стандартных параметров классификатора), следовательно, мы успешно справились с поставленной задачей.

В данной статье я постарался описать решение задачи по созданию классификатора текстовых документов. Здесь представлены только общие шаги, но и они позволили достичь достаточно хорошего результата. Для дальнейшего улучшения модели можно увеличить датасет и провести его дополнительную очистку, попробовать другие классификаторы (например, RandomForestClassifier) и другие сочетания их параметров.

Надеюсь, статья была полезной и поможет вам начать самостоятельно решать nlp-задачи.

Если вы знакомы с Python, то уже сталкивались с Jupyter Notebook или работали в нём по крайней мере один раз. Jupyter Notebook это удобный инструмент, позволяющий писать мини-код и отслеживать его выполнение. Он также помогает в документировании, ведении журнала и в том, чтобы поделиться своими работами с коллегами.

Неудивительно, что многие люди и крупные организации, такие как Netflix, для своих целей в разработке предпочитают Jupyter Notebook. Специально к старту нового потока курса по разработке на Go 26 мая мы решили поделиться переводом, автор которого рассказывает, как документировать проекты на Golang в Jupyter Notebook.

Если вы работаете на машине с Windows, потребуется установка Docker. Пожалуйста, следуйте этим инструкциям. Если вы работаете на Mac или Linux, вы можете либо использовать метод с docker выше, либо следовать процессам локальной установки, о которых я напишу ниже.

Содержание

1. Установка.

2. Запуск Jupyter Notebook.

3. Написание простой программы.

Установка

Установка может показаться сложной, но я постараюсь сделать её как можно проще. Если при настройке вы столкнулись с какими-либо трудностями, пожалуйста, обратитесь к FAQ по устранению неполадок gophernote.

Я приведу три основных метода установки, хотя сам рекомендовал бы подход с *Docker*, поскольку он не зависит от операционной системы, то есть сможет работать на любой операционной системе.

1. Докер (рекомендация)

Вот основная команда:

$ docker run -it -p 8888:8888 -v /path/to/local/notebooks:/path/to/notebooks/in/docker gopherdata/gophernotes:latest-ds

Тег latest-ds указывает докеру, чтобы он извлёк версию пакета gophernotes, где уже установленные библиотеки Data Science, такие как GoNum, GoLearn и GoDa. Команда на вашей машине может выглядеть так:

$ docker run -it -p 8888:8888 -v /home/user/Documents/notebook:/notebook gopherdata/gophernotes:latest-ds

Затем вам будут предоставлены URL-адрес локального хоста подключённого блокнота и соответствующий ему токен. Скопируйте и вставьте его в свой браузер (например localhost:8888/?token=<your_given_token>).

Кроме того, вы сможете увидеть папку notebook, которую указали при инициализации контейнера docker в браузере.

Следуйте приведённым ниже инструкциям, если предпочитаете локальную установку. Однако они работают только для Linux и Mac. Машины с Windows в настоящее время не поддерживаются, и вы должны использовать вышеупомянутый метод Docker.

2. Linux

Вот команды локальной установки для Linux:

$ env GO111MODULE=on go get github.com/gopherdata/gophernotes$ mkdir -p ~/.local/share/jupyter/kernels/gophernotes$ cd ~/.local/share/jupyter/kernels/gophernotes$ cp "$(go env GOPATH)"/pkg/mod/github.com/gopherdata/gophernotes@v0.7.2/kernel/*  "."$ chmod +w ./kernel.json # in case copied kernel.json has no write permission$ sed "s|gophernotes|$(go env GOPATH)/bin/gophernotes|" < kernel.json.in > kernel.json

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

$ "$(go env GOPATH)"/bin/gophernotes

И вы сможете открыть блокнот этой командой:

$ jupyter --data-dir

3. Mac

Аналогично локальную установку для Mac можно выполнить, написав в терминале следующие команды:

$ env GO111MODULE=on go get github.com/gopherdata/gophernotes$ mkdir -p ~/Library/Jupyter/kernels/gophernotes$ cd ~/Library/Jupyter/kernels/gophernotes$ cp "$(go env GOPATH)"/pkg/mod/github.com/gopherdata/gophernotes@v0.7.2/kernel/*  "."$ chmod +w ./kernel.json # in case copied kernel.json has no write permission$ sed "s|gophernotes|$(go env GOPATH)/bin/gophernotes|" < kernel.json.in > kernel.json

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

$ "$(go env GOPATH)"/bin/gophernotes

Теперь можно открыть блокнот этой командой:

$ jupyter --data-dir

Фух, переварить такое довольно трудно. Переходим к частям веселее!

Запуск Jupyter Notebook

Теперь, когда вы настроили Gophernotes, перейдите в папку, где хотите хранить свои блокноты Golang, там мы создадим наш первый блокнот! В правом верхнем углу вы увидите новую кнопку. Нажмите на неё и выберите "Go" в качестве ядра блокнота.

Как только вы сделаете это, вас встретит знакомый чистый блокнот Jupyter. Теперь первым делом нужно изменить название на My First Golang Notebook (или любое другое, как показано ниже):

Давайте напишем какую-нибудь простую программу в наш Golang Notebook.

Рекурсивный факториал

Первое, что делает большинство людей, начиная писать программу на Golang, импорт необходимых пакетов. Программа простая, поэтому давайте импортируем пакет fmt.

Теперь напишем рекурсивный факториал. Факториал числа n это произведение всех положительных целых чисел, меньших или равных n. Например 3!, то есть факториал числа 3, это 3 x 2 x 1 = 6. Записать функцию вычисления факториала можно в одну из ячеек Jupyter Notebook:

Осталось только запустить программу, которая распечатывает значение, вот так:

Бонус

Мощь Jupyter Notebook в возможности аннотирования и комментирования без загромождения кодовой базы. Воспользоваться этими возможностями можно, изменив тип ячейки на markdown, то есть выделить ячейку, нажать ctrl+M и ввести соответствующие примечания.

Заключение

Вот и всё. Теперь вы можете создать прототип приложения Golang и отслеживать его с помощью блокнота Jupyter. Вы можете поделиться этим блокнотом со своими друзьями или коллегами в целях документирования (или если вы хотите помочь новым разработчикам выполнить логический шаг, который выполняете, когда пишете код самостоятельно). Ссылка на репозиторий gophernotes.

А если вам не хочется ограничиваться столь простыми программами на Go, обратите внимание на специальный курс Backend-разработчик на Go. У всех поступивших на курс появляется поддержка в виде экспертов, готовых ответить на вопросы и пояснить нюансы языка. Хотите дополнить свой арсенал навыков умением кодить на GO добро пожаловать. А по ссылке можно ознакомиться с программой курса.

Узнайте, как прокачаться и в других специальностях или освоить их с нуля:

• Профессия Data Scientist

• Профессия Data Analyst

• Курс по Data Engineering

Файлы блокнотов Jupyter, в смысле количества одного из самых быстрорастущих типов файлов на Github, предоставляют простой интерфейс для итераций при решении визуальных задач, будь то анализ наборов данных или написание документов с большим объёмом кода. Однако популярность блокнотов Jupyter сопровождается проблемами: в репозитории накапливается большое количество файлов ipynb, многие из которых находятся в нерабочем состоянии. В результате другим людям трудно повторно запустить или даже понять ваши блокноты. В этом руководстве рассказывается, как для автоматизации сквозного (end-to-end) тестирования блокнотов можно воспользоваться плагином pytest nbmake.

К старту флагманского курса о Data Science области, в которой блокноты Jupyter незаменимы делимся переводом статьи из блога CI Semaphore о том, как при помощи Semaphore проверить, что ваши блокноты Jupyter находятся в рабочем состоянии и для этого больше не запускать блокноты вручную.

Предварительные требования

Это руководство предполагает владение основными навыками тестирования проектов на Python, о них рассказывается в статьеНепрерывная интеграция и развёртывание на Python с нуля. Прежде чем продолжить, пожалуйста, убедитесь, что вы знакомы с основами и на вашем компьютере установлен набор инструментов Python 3, таких как pip + virtualenv.

Демонстрационное приложение

Обычно проекты Python содержат папки с файлами блокнотов с расширением .ipynb, это может быть:

• код доказательства концепции;

• документация с примерами применения API;

• длинный научный туториал.

В этой статье мы разберём, как автоматизировать простые сквозные тесты некоторых блокнотов, содержащих упражнения на Python. Благодарим pytudes за предоставленные для нашего примера материалы; воспользуемся этим примером проекта, не стесняйтесь делать форк и клонировать его с GitHub:

Внутри репозитория вы найдёте содержащую блокноты папку, она называется ipynb. Установите зависимости из requirements.txt, а при необходимости сначала создайте виртуальную среду.

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

Локальное тестирование блокнота

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

Давайте начнём автоматизировать этот процесс в вашей среде разработки; первым шагом в автоматизации станет nbmake. Nbmake это пакет python и плагин к pytest. Он разработан автором этого руководства и используется известными научными организациями, такими как Dask, Quansight и Kitware. Вы можете установить nbmake с помощью pip:

pip install nbmake==0.5

Перед первым тестированием блокнотов давайте проверим, всё ли правильно настроено, указав pytest просто собрать (но не запускать) все тест-кейсы для блокнотов.

 pytest --collect-only --nbmake "./ipynb" ================================ test session starts =================================platform darwin -- Python 3.8.2, pytest-6.2.4, py-1.10.0, pluggy-0.13.1rootdir: /Users/a/git/alex-treebeard/semaphore-demo-python-jupyter-notebooksplugins: nbmake-0.5collected 3 items           ============================= 3 tests collected in 0.01s =============================

Мы видим, что pytest собрал несколько элементов.

Примечание: если вы получаете сообщение unrecognized arguments: --nbmake, оно означает, что плагин nbmake не установлен. Такое может произойти, если ваш CLI вызывает двоичный файл pytest за пределами текущей виртуальной среды. Проверьте, где находится ваш двоичный файл pytest, с помощью команды which pytest.

Теперь, когда мы проверили, что nbmake и pytest видят ваши блокноты и работают вместе, давайте выполним настоящие тесты:

 pytest --nbmake "./ipynb"================================ test session starts =================================platform darwin -- Python 3.8.2, pytest-6.2.4, py-1.10.0, pluggy-0.13.1rootdir: /Users/a/git/alex-treebeard/semaphore-demo-python-jupyter-notebooksplugins: nbmake-0.5collected 3 items                                                                    ipynb/Boggle.ipynb .                                                           [ 33%]ipynb/Cheryl-and-Eve.ipynb .                                                   [ 66%]ipynb/Differentiation.ipynb .                                                  [100%]================================= 3 passed in 37.65s =================================

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

Игнорирование ожидаемых ошибок в блокноте

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

К счастью, чтобы указать nbmake, что такие блокноты нужно игнорировать и продолжать работу после возникновения ошибок, в метаданные нашего блокнота мы можем поместить директивы. Возможно, вы раньше не использовали метаданные блокнота, поэтому самое время упомянуть, что, несмотря на их расширение ipynb, блокноты это просто JSON-файлы. Чтобы добиться от них нового поведения, добавьте новые поля:

• откройте файл .ipynb в простом текстовом редакторе, например Sublime;

• в метаданных блокнота найдите поле kernelspec;

• добавьте объект execution в качестве родственного элемента kernelspec.

Должно получиться что-то вроде этого:

{  "cells": [ ... ],  "metadata": {    "kernelspec": { ... },    "execution": {      "allow_errors": true,      "timeout": 300    }  }}

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

Ускорение тестов с помощью pytest-xdist

В крупных проектах может быть много блокнотов, каждый из которых требует много времени на установку пакетов, извлечение данных из сети и выполнение анализа. Если ваши тесты занимают более нескольких секунд, стоит проверить, как на время выполнения повлияет распараллеливание. Сделать это можно с помощью другого плагина pytest pytest-xdist. Сначала установите пакет xdist. Это похожий на nbmake плагин pytest, он добавит новые параметры командной строки:

pip install pytest-xdist

Запустите команду ниже с количеством рабочих процессов, равным auto:

pytest --nbmake -n=auto "./ipynb"

Запись выполненных блокнотов обратно в репозиторий

По умолчанию тесты доступны только для чтения, то есть ваш файл ipynb на диске остаётся неизменным. Обычно это хорошее значение по умолчанию, потому что во время выполнения блокнота ваш редактор может быть открыт. Однако в некоторых ситуациях может потребоваться сохранить результаты теста на диске. Например, если вам нужно:

• отладить неработающие блокноты путём просмотра выходных данных;

• создать коммит в вашем репозитории с блокнотами в воспроизводимом состоянии;

• встроить выполненные блокноты в сайт с документацией при помощи nbsphinx или jupyter book.

Мы можем направить nbmake на сохранение выполненных блокнотов на диск с помощью флага overwrite:

pytest --nbmake --overwrite "./ipynb"

Исключение блокнотов из тестов

Некоторые блокноты может быть трудно протестировать автоматически из-за необходимости ввода данных через stdin самим пользователем или длительного времени запуска. Чтобы отменить выбор, воспользуйтесь флагом игнорирования pytest:

pytest --nbmake docs --overwrite --ignore=docs/landing-page.ipynb

Примечание: это не сработает, если вы выбираете все блокноты с помощью шаблона поиска, например (*ipynb), вручную переопределяющего флаги игнорирования pytest.

Автоматизация тестирования блокнотов на Semaphore CI

С помощью вышеописанных методов можно создать автоматизированный процесс тестирования с использованием непрерывной интеграции (CI) Semaphore. Ключ здесь прагматизм: нужно найти способ протестировать большую часть ваших блокнотов и проигнорировать сложные блокноты; это хороший шаг к улучшению качества.

Начните с создания содержащего ваши блокноты проекта для репозитория. Выберите Choose repository:

Затем подключите Semaphore к репозиторию с вашими блокнотами:

Пока пропустите Add People, чтобы мы могли настроить рабочий процесс с нуля (даже если вы работаете с деморепозиторием). Semaphore предоставляет некоторую начальную конфигурацию, настроим её перед запуском:

Создайте простой рабочий процесс в один блок; ниже о процессе в деталях:

1. Названием блока будет Test.

2. Названием задачи Test Notebooks.

3. В поле Commands введите команды ниже:

checkoutcache restorepip install -r requirements.txtpip install nbmake pytest-xdistcache storepytest --nbmake -n=auto ./ipynb

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

1. checkout клонирует репозиторий с GitHub;

2. cache restore загружает зависимости Python из кэша Semaphore. Это ускоряет процесс установки;

3. pip устанавливает зависимости и инструменты;

4. cache store сохраняет загруженные зависимости обратно в кэш;

5. pytest запускает тесты nbmake.

Теперь мы можем запустить рабочий процесс. Не беспокойтесь, если конвейер выйдет из строя: далее мы рассмотрим распространённые проблемы.

Конвейер должен заработать сразу же:

Устранение некоторых распространённых ошибок

Добавление отсутствующего ядра Jupyter в среду CI

Если вы используете имя ядра, отличное от имени по умолчанию python3, то при выполнении ноутбуков в свежей среде CI увидите сообщение об ошибке: Error - No such kernel: 'mycustomkernel'. Чтобы установить пользовательское ядро, воспользуйтесь командой ipykernel:

python -m ipykernel install --user --name mycustomkernel

Если в своих блокнотах вы работаете с другим языком, например С++, ваш процесс установки ядра может быть другим.

Добавление недостающих секретов в среду CI

В некоторых случаях ваш блокнот получает данные от API, требующих токена или аутентифицированного CLI. Всё, что работает в вашей среде разработки, должно работать и на Semaphore. Чтобы увидеть, как настроить секреты, сначала посмотрите этот пост. Как только вы установили секреты в Semaphore, чтобы прочитать их из переменной среды в средах CI, вам может потребоваться настроить блокнот.

Добавление недостающих зависимостей в среду CI

Стек Data Science на Python часто требует установки собственных библиотек. Если вы работаете с CONDA, вполне вероятно, что они будут присутствовать в вашем нормальном процессе установки. Если же вы используете стандартные библиотеки Python, их присутствие немного менее вероятно.

Если вы пытаетесь установить необходимые вам библиотеки, посмотрите на статью о создании образа docker в CI. С ним тестирование упрощается, и по сравнению со стандартными средами Semaphore этот подход стабильнее во времени.

Пожалуйста, помните совет о прагматизме; 90 % полезности часто можно достичь за 10 % времени. Следование совету может привести к компромиссам, таким как игнорирование блокнотов, на которых запускаются требующие GPU модели ML.

Заключение

В этом руководстве показано, как можно автоматизировать тестирование блокнотов Jupyter, чтобы поддерживать их воспроизводимость. Блокноты оказались эффективным инструментом для построения технических нарративов. Однако из-за новизны некоторые команды разработчиков программного обеспечения исключают их использование до тех пор, пока не появятся более чёткие процессы для тестирования, ревью и повторного использования их содержимого.

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

• для удаления громоздких выходных данных блокнота перед коммитом запустите pre-commit и nbstripout;

• для компиляции ваших блокнотов в красивый сайт с документацией используйте jupyter book;

• для просмотра блокнотов в пул-реквестах используйте ReviewNB.

Действительно, процессы в разработке ПО и в научных исследованих всё дальше уходят с локальных компьютеров на арендуемые мощности самого разного рода, в том числе потому, что требуют всё больших ресурсов. То же касается и растущих объёмов данных, работа с которыми преобразилась в несколько смежных, но очень разных областей; среди них центральное место занимает Data Science. Если вам интересна эта сфера, вы можете присмотреться к нашему курсу Data Science, итог которого это 16 проектов, то есть 2-3 года постоянного самостоятельного изучения науки о данных.

Узнайте, как прокачаться и в других специальностях или освоить их с нуля:

• Профессия Data Scientist

• Профессия Data Analyst

• Курс по Data Engineering

Мы рады сообщить, что стал доступен июньский релиз расширения Jupyter для Visual Studio Code. Если вы работаете с Python, мы рекомендуем загрузить расширение Python из Marketplace или установить его прямо из галереи расширений в Visual Studio Code. Если у вас уже установлено расширение Python, вы также можете получить последнее обновление, перезапустив Visual Studio Code. Узнайте больше о поддержке Python в Visual Studio Code в документации.

В этом релизе основное внимание уделялось:

• Усилению мер безопасности

• Дополнительным настройкам макета Native Notebook

• Улучшению средств Data Viewer и Variable Explorer

Если вам интересно, вы можете изучить полный список улучшений в нашем журнале изменений.

Подробнее о самых интересных новинках под катом.

Workspace Trust

Команда Visual Studio Code серьезно относится к безопасности. Функция Workspace Trust позволяет определить, каким папкам и содержимому проекта вы доверяете, а какие остаются в ограниченном режиме.

Что это значит для notebooks?

При открытии папки в VS Code вас спросят, доверяете ли вы авторам и содержимому папок.

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

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

Дополнительные сведения и сведения о доверии рабочей области см. в разделе Visual Studio Code - доверие рабочей области.

Улучшенная фильтрация в средстве просмотра данных

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

Сортировка в проводнике переменных

По многочисленным просьбам переменные в вашем notebook теперь можно сортировать. Щелкните заголовок Имя или Тип в проводнике переменных для сортировки. Направление стрелки в заголовке будет указывать, по какому заголовку сортируются переменные и в каком порядке выполняется сортировка: в алфавитном или обратном алфавитном порядке.

Новый взгляд на нативные notebooks

Чтобы опробовать нативные notebooks сегодня, загрузите VS Code Insiders и расширение Jupyter. Расширение Python настоятельно рекомендуется для работы с записными книжками Python.

• Панель инструментов notebook теперь находится в верхнем левом углу со всеми вашими любимыми действиями и функциями, связанными с notebook

• Средство выбора ядра переместилось обратно в верхний правый угол, что упрощает переключение между средами

• Индикатор ячейки выделился жирным шрифтом. Вы можете найти этот индикатор более полезным, чтобы определить, где вы находитесь в записной книжке, особенно при работе с длинными ячейками и выводами.

Кастомизируемые нативные notebooks

Хотя приведенные выше основные моменты показывают, что уже работает в notebooks из коробки, вы всегда можете настроить все по своему вкусу. Мы добавили ряд настроек, чтобы по-настоящему сделать ваш notebook идеальным. Чтобы изучить настройки макета notebook, щелкните значок Дополнительные действия в конце панели инструментов и выберите Настроить макет notebook.

Вы попадете на страницу настроек со всеми настройками макета, относящимися к notebook, где вы сможете создать идеальный макет, который вам больше нравится.

Полный список настроек компоновки notebook:

• notebook.insertToolbarLocation

• notebook.consolidatedRunButton

• notebook.cellFocusIndicator

• notebook.cellToolbarVisibility

• notebook.compactView

• notebook.consolidatedOutputButton

• notebook.dragAndDropEnabled

• notebook.globalToolbar

• notebook.showCellStatusBar

• notebook.showFoldingControls

• notebook.editorOptionsCustomizations

Прочие изменения и улучшения

Мы также добавили небольшие улучшения и исправили проблемы, запрошенные пользователями, которые должны улучшить ваш опыт работы с notebooks в Visual Studio Code. Некоторые заметные изменения включают:

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

• Добавление ABCMeta и ввод в список исключений проводника переменных

• Настройка размера и вида переменных в соответствии с VS Code

• Скрытие ядер, принадлежащих удаленным средам Python, из средства выбора ядра

Загрузите расширение Python и расширение Jupyter для Visual Studio Code сейчас, чтобы опробовать вышеуказанные улучшения. Если у вас возникнут какие-либо проблемы или у вас есть предложения, сообщите о проблеме на странице Jupyter VS Code GitHub.

Привет, Хабр!

На связи команда Datalore by JetBrains. Хотим поделиться с вами результатами анализа нескольких миллионов публично доступных репозиториев Github с Jupyter-ноутбуками. Мы скачали ноутбуки, чтобы немного больше узнать в цифрах о текущем статусе, пожалуй, самого популярного инструмента для data science.

Вдохновившись исследованием, проведенным командой Design Lab из UC San Diego, мы дважды скачали Jupyter-ноутбуки: в октябре 2019 и в октябре 2020.

Два года назад в открытом доступе было 1,23 миллиона ноутбуков. В октябре 2020 года число ноутбуков выросло в 8 раз, и мы смогли скачать 9,72 миллиона файлов. Этот датасет мы сделали публичным инструкцию по скачиванию можно найти в конце поста.

Все цифры и графики были подсчитаны в этом Datalore ноутбуке. Datalore это онлайн Jupyter-ноутбуки с умной поддержкой кода, которые мы делаем в JetBrains. Вы можете создать копию ноутбука, перейдя по ссылке, и работать с данными в Datalore.

Мы будем рады, если вы захотите поработать с данными и провести собственный анализ. Делитесь с нами результатами, отмечая в Твиттере @JBDatalore или написав нам на contact@datalore.jetbrains.com.

Теперь перейдем к цифрам.

Язык data science

Несмотря на большой рост популярности R и Julia в последние годы, Python остается лидирующим программным языком для Jupyter-ноутбуков.

Помимо этого встречаются ноутбуки, написанные на Bash, MatLab и Scilab, а также на языках, с которыми ноутбуки ассоциируются, пожалуй, в последнюю очередь: Scala, C++ и Java.

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

В табличке можно увидеть разницу в процентах использования Python 2 и Python 3 в ноутбуках в 2018, 2019 и 2020 годах.

Количество ноутбуков, написанных на Python 3, увеличилось с 2019 года на 87%, а количество ноутбуков с Python 2 на 12%.

На графике ниже можно увидеть распределение количества ноутбуков, написанных на Python и R, по версиям языков:

Топ библиотек data science

Чтобы помочь пользователям Datalore начать работу с ноутбуками как можно быстрее, мы предустановили самые используемые Python-библиотеки. Для этого мы посчитали статистику импортов в скачанных Jupyter-ноутбуках.

Не оказалось неожиданностью, что 60% ноутбуков содержат в списке зависимостей Numpy, 47% импортируют Pandas и Matplotlib.

Более подробную информацию можно увидеть на графике:

Самые популярные комбинации библиотек:

Рост PyTorch и TensorFlow

Члены нашей команды интересуются библиотеками для глубинного обучения, и мы решили сравнить рост библиотек PyTorch и TensorFlow.

Из таблицы ниже можно увидеть, что число импортов у PyTorch растет значительно быстрее, чем у TensorFlow.

В то же время нужно учитывать, что библиотека Keras может использовать TensorFlow в качестве транзитивной зависимости, а Fast.ai использует PyTorch в качестве зависимости. Это означает, что скорость роста TensorFlow, вероятно, выше, но мы не можем говорить с уверенностью, какая из библиотек больше использовалась в последние годы.

Содержание ячеек в ноутбуках

Немного общих цифр относительно ячеек (данные подсчитаны для ноутбуков, написанных на Python 3.6 и выше):

• 71,90% ноутбуков содержат Markdown.

• 42,13% ноутбуков содержат графики или картинки в output.

• 12,34% ноутбуков содержат LaTex.

• 19,77% ноутбуков содержат HTML.

• 20,63% ноутбуков содержат код внутри Markdown.

Markdown очень широко используется в Jupyter-ноутбуках. 50% ноутбуков содержат более 4 ячеек Markdown и более 14 ячеек кода.

Графики ниже показывают распределения Markdown-ячеек и ячеек с кодом:

На графике ниже можно увидеть распределение количества строк кода. Хотя существуют отдельные экземпляры ноутбуков, имеющие более 25 000 строк кода, 95% ноутбуков содержат менее 465 строк:

Использование графиков тоже популярно. Выше мы упоминали, что 42% ноутбуков содержат визуализации. 10% этих ноутбуков содержат более 8 изображений.

Воспроизводимость Jupyter-ноутбуков

Для Jupyter-ноутбуков существует проблема не всегда готовый ноутбук можно воспроизвести. Зачастую это означает, что ячейки были выполнены автором не в прямой последовательности. Мы проверили порядок выполнения ячеек кода всех доступных Jupyter-ноутбуков и выяснили, что 36% Jupyter-ноутбуков выполнены в нелинейном порядке, т. е. при исполнении кода линейно результат выполнения может отличаться.

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

Количество Jupyter-ноутбуков невероятно выросло за последние годы, и в этом исследовании мы постарались побольше узнать об этом очень популярном инструменте работы над задачами data science.

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

Ссылки

Предыдущее исследование 2018 года

Ноутбук в Datalore с предобработанными данными

Инструкция по получению доступа к данным:

1. Скачайте оригинальный датасет:

   1. Ссылка для скачивания исходных данных из бакета (10 млн файлов, 4,4 ТБ): https://github-notebooks-update1.s3-eu-west-1.amazonaws.com/

   2. Получение списка файлов c помощью AWS S3 API может занять время, поэтому воспользуйтесь этим JSON со всеми именами файлов: https://github-notebooks-samples.s3-eu-west-1.amazonaws.com/ntbslist.json

   3. Добавьте имя файла из JSON к адресу бакета, чтобы получить прямую ссылку, например: https://github-notebooks-update1.s3-eu-west-1.amazonaws.com/0000036466ae1fe8f89eada0a7e55faa1773e7ed.ipynb

2. Или воспользуйтесь предобработанными данными из исследования (3 ГБ). Файлы доступны в этом Datalore-ноутбуке.