{ "version": "https:\/\/jsonfeed.org\/version\/1", "title": "Блог об аналитике, визуализации данных, data science и BI, заметки с тегом: аналитика", "home_page_url": "http:\/\/test.leftjoin.ru\/tags\/analitika\/", "feed_url": "http:\/\/test.leftjoin.ru\/tags\/analitika\/json\/", "icon": "http:\/\/test.leftjoin.ru\/user\/userpic@2x.jpg", "author": { "name": "Николай Валиотти", "url": "http:\/\/test.leftjoin.ru\/", "avatar": "http:\/\/test.leftjoin.ru\/user\/userpic@2x.jpg" }, "items": [ { "id": "122", "url": "http:\/\/test.leftjoin.ru\/all\/youtube-api\/", "title": "How to: YouTube API", "content_html": "

Современным аналитикам необходимо обладать навыком сбора информации из социальных сетей, ведь сейчас контент социальных сетей очень точно отражает реальную ситуацию в мире, помогает быстро распространить новости и позволяет анализировать аудиторию — подписчиков. В предыдущих постах мы уже описывали кейсы с использованием различных API: Vkontakte API<\/a>, Facebook API<\/a>, GitHub API<\/a>. Сегодня мы расскажем вам о том, что представляет из себя YouTube API, как получить ключ API, а также наглядно покажем, какую информацию можно собрать с его помощью. В двух словах, с помощью YouTube API можно находить каналы по ключевым словам, выгружать данные канала, а также статистику по видео, опубликованным на этих каналах.<\/p>\n

Подготовительный этап для работы с YouTube API<\/h2>\n

\tДля начала, нужно разобраться в том, как получить доступ к API. Этот процесс подробно изложен на сайте для разработчиков, на который вы можете перейти по ссылке. Если коротко, то необходимо иметь или завести аккаунт Google, войти в профиль для разработчиков, создать проект, получить ключ API и подключить к нему API YouTube Data API v3. Далее, с использованием этого ключа вам будет доступен весь необходимый функционал.
\n\tПосле того, как вы успешно получили ключ, можно открывать любой удобный ноутбук (Jupyter Notebook, Collab и т. д.), устанавливать и подключать нужные для работы библиотеки.<\/p>\n

# установка библиотек\r\n\tpip install --upgrade google-api-python-client\r\n\tpip install --upgrade google-auth-oauthlib google-auth-httplib2\r\n\t# импорт необходимых библиотек\r\nimport googleapiclient.discovery\r\nimport time<\/code><\/pre>
Квоты<\/h2>\n
Один важный момент, который важно знать при использовании Youtube API — это наличие дневных квот на использование функций YouTube API в бесплатном режиме.  На день дается квота 10000 юнитов, вызов функции поиска стоит 100 юнитов, вызов информации по объекту — 1 юнит, загрузка видео на YouTube стоит 1600 юнитов. Если вам недостаточно дневной квоты, то вы можете подать запрос в Google на её увеличение, в котором нужно подробно указать цели вашей деятельности c YouTube API.<\/p>\n
Поиск YouTube-каналов по ключевым словам<\/h2>\n
Для начала заведем несколько переменных, которые понадобятся нам в процессе сбора информации.<\/p>\n
channels_data = {}\r\nchannels_data_full = {}\r\nvideo_data = {}<\/code><\/pre>
Дальше написан скрипт, который можно использовать для поиска перечня каналов по ключевым словам. Мы искали каналы, в названии или описании которых используются следующие слова:  s_query = ’аналитика данных data’. Сначала выводятся каналы, в названии или описании которых присутствуют все три слова, затем хотя бы любые два, затем хотя бы одно. Чем больше ключевых слов по теме мы укажем, тем точнее будет результат.<\/p>\n
api_service_name = "youtube"\r\napi_version = "v3"\r\nDEVELOPER_KEY = "" #тут нужно указать ключ, который вы получите при подключении YouTube API\r\n \r\nyoutube = googleapiclient.discovery.build(\r\n   api_service_name, api_version, developerKey = DEVELOPER_KEY)\r\n#строка поиска\r\ns_query = 'аналитика данных data'\r\nnext_token = ''\r\n \r\nwhile(True): \r\n time.sleep(0.2)\r\n request = youtube.search().list(\r\n     part="snippet",\r\n     q=s_query,\r\n     relevanceLanguage="ru",\r\n     type="channel",\r\n     maxResults=25,\r\n     access_token=DEVELOPER_KEY,\r\n     pageToken = next_token\r\n )\r\n response = request.execute()\r\n for item in response['items']:\r\n   channels_data[item['snippet']['channelId']] = [item['snippet']['title'], item['snippet']['description']\r\n   ]\r\n #берем только первые 25 результатов\r\n break<\/code><\/pre>
Добавим пару важных пояснений относительно скрипта. В начале цикла в этом скрипте (как и в двух последующих) мы вызываем функцию time.sleep(), чтобы инициировать двухсекундную задержку между вызовом функций. Это нужно для того, чтобы запросы к YouTube не были чересчур частыми (и вообще, это считается правилом хорошего тона в программировании, так что советуем взять на заметку).
\nДля простоты нашего примера мы сохранили только 25 первых каналов из всех подходящих под условия поиска. Если вам хочется найти все каналы, в которых упоминается хотя бы одно из ключевых слов, то нужно использовать следующее свойство:<\/p>\n
try:\r\n    next_token = response["nextPageToken"]\r\n  except:\r\n    break<\/code><\/pre>
Сбор полной информации по всем выбранным каналам<\/h2>\n
Теперь, когда названия и описания выбранных каналов собраны, можно переходить к следующему этапу, а именно — выгрузке всей информации об этих каналах, в том числе: количество подписчиков канала, количество видео, общее количество просмотров всех видео канала и страна в которой живет, автор канала.<\/p>\n
scount = ''\r\nfor channel in channels_data:\r\n   #получаем данные по каждому каналу\r\n   time.sleep(0.2)\r\n   r = youtube.channels().list(\r\n         part="snippet, statistics",\r\n         id=channel,\r\n         access_token=DEVELOPER_KEY\r\n   )\r\n   resp = r.execute()\r\n        \r\n   try:\r\n     if resp['items'][0]['statistics']['hiddenSubscriberCount']:\r\n       scount = 'hidden'\r\n     else:\r\n       scount = resp['items'][0]['statistics']['subscriberCount']\r\n  \r\n     channels_data_full[channel] = [resp['items'][0]['snippet']['title'],\r\n                                  resp['items'][0]['snippet']['description'],\r\n                                  scount,\r\n                                  resp['items'][0]['statistics']['videoCount'],\r\n                                  resp['items'][0]['statistics']['viewCount'],\r\n                                  resp['items'][0]['snippet']['country']\r\n     ]\r\n      \r\n   except:\r\n     pass<\/code><\/pre>
Теперь вся нужная информация о канале хранится в переменнной channels_data_full.<\/p>\n
Получение информации о видео<\/h2>\n
Если у вас есть необходимость получить статистику по видео из выбранных каналов, то ниже приведен скрипт на этот случай. В итоге, вы получите словарь   video_data  с подробной информацией о каждом видео из плейлиста (список всех видео каждого канала): название канала, дата публикации, название и описание видео, количество просмотров, лайков\/дизлайков и комментариев.<\/p>\n
# получаем информацию по всем видео ранее найденных каналов\r\nfor channel in channels_data:\r\n   #анализируем каналы\r\n   time.sleep(0.2)\r\n   r = youtube.channels().list(\r\n           part="contentDetails",\r\n           id=channel,\r\n           access_token=DEVELOPER_KEY\r\n     )\r\n   resp = r.execute()           \r\n   try:\r\n     #получаем плейлист из видео для одного канала из списка\r\n     id_playlist = resp['items'][0]['contentDetails']['relatedPlaylists']['uploads']     \r\n     #получаем набор элементов плейлиста (видео)\r\n     next_token = ''\r\n     while(True):     \r\n       time.sleep(0.2)\r\n       r = youtube.playlistItems().list(\r\n             part="contentDetails",\r\n             playlistId=id_playlist,\r\n             access_token=DEVELOPER_KEY,\r\n             pageToken = next_token\r\n       )\r\n       resp = r.execute()\r\n       for i in resp['items']:\r\n         id_videos = i['contentDetails']['videoId']\r\n         r = youtube.videos().list(\r\n               part="snippet, statistics",\r\n               id=id_videos,               \r\n               access_token=DEVELOPER_KEY\r\n         )\r\n         resp1 = r.execute()       \r\n         video_data[id_videos] = [channel,\r\n                                   resp1['items'][0]['snippet']['publishedAt'],\r\n                                   resp1['items'][0]['snippet']['title'],\r\n                                   resp1['items'][0]['snippet']['description'],\r\n                                   resp1['items'][0]['statistics']['viewCount'],\r\n                                   resp1['items'][0]['statistics']['likeCount'],\r\n                                   resp1['items'][0]['statistics']['dislikeCount'],\r\n                                   resp1['items'][0]['statistics']['commentCount']\r\n          ]\r\n       break<\/code><\/pre>
В конце мы ставим break, то есть обрабатываем только одну часть видео из плейлиста. Если вы хотите обработать все видео, то нужно использовать функцию nextpagetoken, которую мы предложили в конце первого скрипта.
\nВ итоге, если трансформировать словарь в привычный датафрейм, мы получим таблицу, которая содержит подробную информацию про все обработанные видео.<\/p>\n
d = {'id': [x for x in video_data],\r\n      'channel_id': [video_data[x][0] for x in video_data],\r\n       'published_at': [video_data[x][1] for x in video_data],\r\n      'title': [video_data[x][2] for x in video_data],\r\n      'description': [video_data[x][3] for x in video_data],\r\n      'viewCount': [video_data[x][4] for x in video_data],\r\n      'likeCount': [video_data[x][5] for x in video_data],\r\n      'dislikeCount': [video_data[x][6] for x in video_data],\r\n      'commentCount': [video_data[x][7] for x in video_data]\r\n   }\r\ndf = pd.DataFrame(d)\r\ndf.head()<\/code><\/pre>
\n\"\"\n<\/div>\n
Выводы<\/h2>\n
Конечно, это не все способы работы с YouTube API, однако, мы надеемся, что вы получили представление о том, как сильно расширяются возможности аналитика для получения и обработки информации с помощью этого инструмента.<\/p>\n",
            "date_published": "2021-10-26T13:13:34+03:00",
            "date_modified": "2021-10-26T13:13:27+03:00",
            "image": "http:\/\/test.leftjoin.ru\/pictures\/dataframe.png.jpg",
            "_date_published_rfc2822": "Tue, 26 Oct 2021 13:13:34 +0300",
            "_rss_guid_is_permalink": "false",
            "_rss_guid": "122",
            "_e2_data": {
                "is_favourite": false,
                "links_required": [
                    "system\/library\/highlight\/highlight.js",
                    "system\/library\/highlight\/highlight.css",
                    "system\/library\/highlight\/highlight.js",
                    "system\/library\/highlight\/highlight.css",
                    "system\/library\/highlight\/highlight.js",
                    "system\/library\/highlight\/highlight.css",
                    "system\/library\/highlight\/highlight.js",
                    "system\/library\/highlight\/highlight.css",
                    "system\/library\/highlight\/highlight.js",
                    "system\/library\/highlight\/highlight.css",
                    "system\/library\/highlight\/highlight.js",
                    "system\/library\/highlight\/highlight.css",
                    "system\/library\/highlight\/highlight.js",
                    "system\/library\/highlight\/highlight.css"
                ],
                "og_images": [
                    "http:\/\/test.leftjoin.ru\/pictures\/dataframe.png.jpg"
                ]
            }
        },
        {
            "id": "111",
            "url": "http:\/\/test.leftjoin.ru\/",
            "title": "Анализируем речь в Python: О чем говорят гости youtube-канала вДудь",
            "content_html": "
Сегодня при помощи ML мы будем анализировать прямую речь. В качестве данных используем интервью, которые журналист Юрий Дудь берет для своего YouTube-канала.
\nВыход практически каждого ролика на канале «вДудь» считается событием, а некоторые из этих релизов даже сопровождаются скандалами из-за неосторожных высказываний его гостей.
\nПосмотрим с помощью Python и лемматизации о чем таком интересном рассказывали герои роликов канала «вДудь».<\/p>\n
Парсим тексты субтитров<\/b>
\nВ этом проекте мы будем использовать библиотеки, которые обрабатывают тексты, но сначала нам нужно эти тексты добыть. Импортируем API-интерфейс Python youtube_transcript_api<\/span>, который скачивает субтитры из видео на YouTube.<\/p>\n
import pandas as pd\r\nimport numpy as np\r\n\r\nfrom youtube_transcript_api import YouTubeTranscriptApi\r\nimport json<\/code><\/pre>
Предобработаем URL видео для скачивания субтитров. Всего мы собрали 100 роликов с интервью. В некоторых из интервью нет подготовленных субтитров. В файле ‘dud.csv’<\/span> заранее подготовлен список гостей канала вДудь с ссылками на их интервью.<\/p>\n
def new_url(s):\r\n    return s.replace('watch?v=','').replace('be.com','.be').replace('www.','')\r\n\r\ndef url_to_id(s):\r\n    return s.partition('be\/')[2]\r\n\r\ndf = pd.read_csv('dud.csv')\r\ndf['URL'] = df['URL'].apply(new_url)\r\ndf['video_id'] = df['URL'].apply(url_to_id)\r\ndf = df.set_index(keys='Гость')<\/code><\/pre>
У нас теперь есть датафрейм, в котором пока только информация о гостях и ссылка на видео. Но это пока.<\/p>\n
\n\"\"\n<\/div>\n
Загрузим в нашу таблицу субтитры интервью. Если субтитры найти не удалось, то выведем на экран имена людей, к интервью с которыми их нет или они отключены (или субтитры есть, но не на русском языке).<\/p>\n
texts = []\r\nno_sub = []\r\nfor speaker in df.index:\r\n    video_id = df.loc[speaker,'video_id']\r\n    try:\r\n        data = YouTubeTranscriptApi.get_transcript(video_id, languages=['ru', 'ru'])\r\n        data = ' '.join([words['text'] for words in data])\r\n    except Exception:\r\n        print('Нет Субтитров для: ', speaker)\r\n        no_sub.append(speaker)\r\n        data = ""\r\n    texts.append(data)\r\ndf['text'] = texts\r\ndf.to_csv('df_dud.csv')<\/code><\/pre>
У девяти из 100 интервьюируемых субтитров не оказалось и нам вернулся такой текст:<\/p>\n
Нет Субтитров для:  L'one\r\nНет Субтитров для:  Шнур\r\nНет Субтитров для:  Ресторатор\r\nНет Субтитров для:  Амиран\r\nНет Субтитров для:  Ильич\r\nНет Субтитров для:  Соболев\r\nНет Субтитров для:  Иван Дорн\r\nНет Субтитров для:  Навальный\r\nНет Субтитров для:  Noize MC<\/code><\/pre>
Анализируем тексты<\/b>
\nАнализ текстовой информации сложен в той степени, в какой сложен язык, на котором написан текст. Самый популярный способ решения такой аналитической задачи — стемминг. Стеммингом называют процесс нахождения стема — основы слова. Для стемминга используют библиотеку NLTK (Natural Language Toolkit), которая содержит правила образования стемов.
\nЭтот метод хорошо работает с английскими словами, но у русского языка слишком сложно устроена морфология образования слов, что повышает вероятность ошибки. Стемминг будет хорошим выбором для анализа строк, содержание которых вы примерно представляете себе (например, когда пользователя просят заполнить форму).
\nДля нашего кейса лучше выбрать лемматизацию — приведение слова к его словарной форме. Проведя лемматизацию текстовых данных по правилам русского языка мы получим существительные в именительном падеже единственного числа (кошками — кошка), прилагательные в именительном падеже мужского рода (пушистая — пушистый), а глаголы в инфинитиве несовершенного вида (бежит — бежать). В этом проекте мы используем MyStem и Pymorphy. Обе библиотеки представляют собой морфологические анализаторы.
\nКроме того, поскольку при анализе  мы будем использовать алгоритмы машинного обучения, то нам нужно избавиться от слов, которые часто встречаются, но не несут какой-то ценности для анализа. В противном случае они могут повлиять на работу модели. Список таких стоп-слов возьмем из библиотеки nltk.corpus<\/span>.
\nМаксимально подробно о подготовке текста к анализу мы рассказывали в материале «Python и тексты нового альбома Земфиры<\/u>»<\/a>. Тут была проведена идентичная работа подготовка текстов, после чего мы посчитали количество уникальных слов (’Unique Words’) и записали, как часто они встречаются в речи собеседников Дудя (‘PPT Unique Words’).<\/p>\n
df['Total Words'] = df['text'].apply(number_words)\r\ndf['Unique Words'] = df['text'].apply(set).apply(len)\r\ndf['PPT Unique Words'] = df['Unique Words'] \/ df['Total Words'] * 100\r\ndf['PPT Unique Words'] = df['PPT Unique Words'].apply(lambda x: round(x,2))\r\ndf.to_csv('df_dud.csv')<\/code><\/pre>
Строим облако слов<\/b>
\nАвтоматизируем построение облака слов для каждого гостя Дудя. Таким образом мы узнаем какие слова встречаются в их речи чаще всего. Для визуализации инсталлируем wordcloud<\/span>, а word_tokenize<\/span> подсчитает количество слов, которые будут встречаться чаще всего.<\/p>\n
import nltk\r\nfrom wordcloud import WordCloud\r\nimport pandas as pd\r\nimport matplotlib.pyplot as plt\r\nfrom nltk import word_tokenize, ngrams\r\n\r\ndef word_cloud(df, occup=None, general=True):\r\n    if occup:\r\n        df = df[df['Род деятельности'] == occup] \r\n    if general:\r\n        data_source = zip([occup], [' '.join([el for el in df['Prepared Text']])])\r\n        col_count, row_count = 1, 1\r\n    else:\r\n        data_source = zip([el for el in df.index], df['Prepared Text']) \r\n        col_count = max(1, df.shape[0] \/\/ 3)\r\n        row_count = df.shape[0] \/\/ col_count + 1\r\n        \r\n    fig = plt.figure()\r\n    plt.figure(figsize=(10, 10))\r\n    fig.patch.set_facecolor('white')\r\n    plt.subplots_adjust(wspace=0.3, hspace=0.2)\r\n    i = 1\r\n    for name, text in data_source:\r\n        tokens = word_tokenize(text)\r\n        text_raw = " ".join(tokens)\r\n        wordcloud = WordCloud(colormap='PuBu', background_color='white', contour_width=10).generate(text_raw)\r\n        plt.subplot(row_count, col_count, i, label=name,frame_on=True)\r\n        plt.tick_params(labelsize=10)\r\n        plt.imshow(wordcloud)\r\n        plt.axis("off")\r\n        plt.title(name,fontdict={'fontsize':12,'color':'grey'},y=1.0)\r\n        plt.tick_params(labelsize=10)\r\n        i += 1\r\n    plt.savefig(f'.\/word_cloud\/{occup}.png', dpi=900)<\/code><\/pre>
У нас получились вот такие облака слов по каждому из гостей программы:<\/p>\n
\n\"\"\n<\/div>\n
Работа с Word2vec<\/b>
\nС помощью библиотеки gensim<\/span> вызываем модуль, который должен представить слова в наших текстах как векторы.<\/p>\n
import plotly.graph_objects as go\r\nimport plotly.figure_factory as ff\r\nfrom scipy import spatial\r\nimport collections\r\nimport pymorphy2\r\nimport gensim\r\n\r\nmorph = pymorphy2.MorphAnalyzer()<\/code><\/pre>
Для работы модели используем бинарный файл ‘model.bin’<\/span>:<\/p>\n
model = gensim.models.KeyedVectors.load_word2vec_format('model.bin', binary=True)<\/code><\/pre>
Модель Word2Vec<\/b> основана на нейронных сетях и позволяет представлять слова в виде векторов, учитывая семантическую составляющую. Ее мы уже использовали в анализе лирики Земфиры. Косинусная мера семантически схожих слов будет стремиться к 1, а  у двух слов, не имеющих ничего общего по смыслу, она близка к 0.
\nНапишем функцию, которая будет принимать список слов из наших интервью, распознавать для каждого часть речи, а затем получать и суммировать вектора — так мы сможем находить вектора не для одного слова, а для целых предложений и текстов.<\/p>\n
def get_vector(word_list):\r\n    vector = 0\r\n    for word in word_list:\r\n        pos = morph.parse(word)[0].tag.POS\r\n        if pos == 'INFN':\r\n            pos = 'VERB'\r\n        if pos in ['ADJF', 'PRCL', 'ADVB', 'NPRO']:\r\n            pos = 'NOUN'\r\n        if word and pos:\r\n            try:\r\n                word_pos = word + '_' + pos\r\n                this_vector = model.word_vec(word_pos)\r\n                vector += this_vector\r\n            except KeyError:\r\n                continue\r\n    return vector<\/code><\/pre>
Для каждого интервью находим вектор и собираем соответствующий столбец в датафрейм:<\/p>\n
vec_list = []\r\nfor word in df['Prepared Text']:\r\n    vec_list.append(get_vector(word.split()))\r\ndf['Vector'] = vec_list<\/code><\/pre>
Напишем функцию, который будет подсчитывать N-граммы для каждого гостя:<\/p>\n
def get_top_five_ngrams(text, n):\r\n    counter = collections.Counter()\r\n    bigrams = list(ngrams(text, n))\r\n    counter.update(bigrams)\r\n    return counter.most_common()[:10]<\/code><\/pre>
Построим топ N-грамм в соответствии с группой:<\/p>\n
top_words = dict.fromkeys(df.index)\r\nfor person in df.index:\r\n    text = df.loc[person,'Prepared Text']\r\n    n_gram = get_top_five_ngrams(text.split(), 1)\r\n    n_list = []\r\n    for item in n_gram:\r\n        n_list.append(item[0][0])\r\n    top_words[person] = n_list\r\nordered_pesrons = df.index\r\ntop_2_words = []\r\nfor person in ordered_pesrons:\r\n    top_2_words.append(top_words[person])\r\ndf['Top bigramms'] = top_2_words<\/code><\/pre>
Напишем функцию, которая будет добавлять самые часто встречающиеся слова в речи интервьюируемого:<\/p>\n
def top_similar(df, occup=None, agg='Person'):\r\n    if occup:\r\n        df = df[df['Род деятельности'] == occup]\r\n    if agg == 'Person':\r\n        top_words_person = dict.fromkeys(df.index)\r\n        for person in df.index:\r\n            vec = df.loc[person, 'Vector']\r\n            words = model.similar_by_vector(vec, topn=10)\r\n            top_words_person[person] = [el[0].split('_')[0] for el in words]\r\n        df_person_words = pd.DataFrame(columns=[agg,'Top Words'])\r\n    elif agg == 'Total':\r\n        top_words_person = {'Total':0}\r\n        vec = df['Vector'].sum()\r\n        words = model.similar_by_vector(vec, topn=10)\r\n        top_words_person['Total'] = [el[0].split('_')[0] for el in words]\r\n        df_person_words = pd.DataFrame(columns=[agg,'Top Words'])\r\n    \r\n    for k,v in top_words_person.items():\r\n        df_person_words = df_person_words.append({agg:k, 'Top Words':v},ignore_index=True)\r\n    df_person_words = df_person_words.set_index(keys=agg) \r\n    \r\n    return df_person_words<\/code><\/pre>
Для дальнейшей работы группируем гостей по цеховой принадлежности. Наверное, можно ожидать, что режиссеры будут обсуждать кино и все, что с ним связано, а музыканты — музыку.<\/p>\n
df_occup = pd.DataFrame(columns=['Occupation', 'Top Words'])\r\nfor occup in df['Род деятельности'].unique():\r\n    words = top_similar(df, occup=occup, agg='Total')['Top Words'][0]\r\n    df_occup = df_occup.append({'Occupation':occup, 'Top Words’:words},ignore_index=True)\r\n\r\nfor i in range(10):\r\n    df_occup[f'Top {i+1} word'] = df_occup['Top Words'].apply(lambda x: x[i])<\/code><\/pre>
У нас получится новый датафрейм с топом слов для каждой категории гостей (музыкант, политик, актер и тд).<\/p>\n
\n\"\"\n<\/div>\n
Анализ риторики гостя<\/b>
\nИспользуя метод similar_by_vector<\/span> для каждого из видов деятельности интервьюируемых, мы получаем список слов, которые наиболее точно описывают тематику текстов.
\nСтоит отметить, что слово «государство» стоит на первом месте не только в интервью политиков и бизнесменов, но и дизайнеров с писателями. Очевидно, что тема разговора у всех профессиональных групп смещена в сторону политики.
\nАктёры, кинокритики и музыканты описываются вполне закономерными для их сфер деятельности словами. А вот у фотографов нет ни слова про фотографию или творчество, но есть «работа», «трудоустройство», «существовать» и “семья”.
\nСравним риторику героев, построив box plot для каждой категории с помощью plotly<\/span>.<\/p>\n
import plotly.express as px\r\n\r\nl = []\r\nfor el,ind in zip(df['Род деятельности'].value_counts(), df['Род деятельности'].value_counts().index):\r\n    if el > 1:\r\n        l.append(ind)\r\n\r\ndf_kpi = df[df['Род деятельности'].isin(l)]\r\nfor kpi in ['Total Words', 'Unique Words','PPT Unique Words']:\r\n    buf_df = df_kpi[['Род деятельности',kpi]]\r\n    fig = px.box(df_kpi, \r\n                 x='Род деятельности',\r\n                 y=kpi,\r\n                )\r\n    fig.show()<\/code><\/pre>