Создание индонезийской лирики с использованием глубокого обучения

Шаг за шагом. от соскабливания до создания «♪ lalala ♪» с нуля. (на английском)

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

Я хочу привыкнуть к письму. Для практики мне нужно начать писать. Поскольку у меня есть хобби по созданию ИИ, я хочу поделиться своими знаниями и опытом по созданию ИИ, чтобы практиковать свои навыки письма. «Индонезийский Lyric Generator» - одно из моих приложений искусственного интеллекта, которое я сделал в свободное время.

Я сделаю эту статью удобной для новичков. Надеюсь, эта статья будет вам полезна: D.

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

Вот наш вступительный текст.

Саат Сенюм Манисму Калбуку

Ян Мунгкин Menjadi Milikmu

терахир кали ку хиланг дарику

ян кау аяк кау дисана

Если вы хотите увидеть реализацию и код этой статьи, вы можете увидеть блокнот по этой ссылке GitHub.

Вступление

На смену старой музыке всегда приходит новая музыка. Люди должны творчески подходить к созданию новой песни. Им нужно время, чтобы создать новую песню. компонент, который они должны думать при создании песни, является лирическим. Для людей, которым трудно подобрать правильное слово при написании лирики (как я), это будет проблемой. Они потратят много времени, чтобы написать текст. Вы когда-нибудь думали помочь им решить проблему?

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

В настоящее время ИИ - одно из самых модных модных словечек, о котором говорят в каждом уголке. Он может легко решить некоторые проблемы, которые довольно сложно для человека. Одна из ветвей искусственного интеллекта - машинное обучение (ML). Машинное обучение - это отрасль области искусственного интеллекта, которая прогнозирует результат на основе заданных данных. Он будет учиться на данных. Когда мы хотим написать текст, я думаю, нам следует взглянуть на какую-нибудь старую песню, чтобы узнать, как они пишут текст. Нам нужно поискать в «шаблоне», как они соединяют каждое слово. Это похоже на машинное обучение, которое учится на заданных данных.

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

Даже я выбираю лирику на индонезийском языке, не волнуйтесь. Я напишу эту статью на английском языке. Если вы хотите понять смысл текста, переведите его с помощью Google Translate или других знакомых инструментов.

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

Контур

Я буду писать статьи в таком порядке:

Инструменты
Шаг
Собирать данные
Предварительная обработка данных
Построить модель
Создать текст
Заключение
Послесловие
Источники

Инструменты

Будут использоваться следующие библиотеки, инструменты и язык программирования:

Python 3.6
Библиотека Python - математические инструменты в Python
Библиотека Python - панды, табличные инструменты данных в Python
Библиотека Python - Keras, фреймворк глубокого обучения. Требуется библиотека Tensorflow, CNTK или Theano.
Библиотека Python - Scrapy, популярные инструменты парсера на Python
Блокнот Jupyter (необязательно) Awesome Python IDE, который также можно использовать для создания презентаций или образовательного кода.

Я использую GPU NVIDIA GTX 1050 для обучения своей модели.

Шаг или конвейер

Вот как мы делаем генератор.

Сначала соберите данные, очистив какой-нибудь веб-сайт, содержащий индонезийские тексты, с помощью scrapy. Затем очистите текстовую лирику, которая все еще содержит тег HTML, с помощью регулярного выражения. После этого обработайте текст в лирике, чтобы его можно было использовать для ввода модели. нам нужно будет построить архитектуру глубокого обучения. Наконец, обучите модель генерировать текст. Я расскажу вам, как я делал это на каждом этапе.

Сбор данных (парсинг веб-страниц)

Я собрал все тексты с сайта коллекции лирических песен Индонезии (lirik.kapanlagi.com). парсинг - это извлечение данных с веб-сайтов. Всю работу выполняет приложение, которое мы создадим. Мы будем использовать библиотеку scrapy для очистки веб-сайта. Информация, которую мы должны извлечь, - это текст и название песни.

В этой статье мы будем использовать lirik.kapanlagi.com в качестве нашей цели.

Сначала создайте проект scrapy, используя эту команду в терминале или командной строке:

scrapy startproject lyric_scrapper

Будет создан новый каталог. Перейдите в новый каталог и выполните эту команду

scrapy genspider lyric_scrapper lirik.kapanlagi.com

Он создаст lyricscrapper.py внутри папки tutorial / spiders. Мы будем называть его поисковым роботом, потому что он «сканирует» целевой веб-сайт. Вот наш код:

# -*- coding: utf-8 -*-
import scrapy
from scrapy.spiders import CrawlSpider, Rule
from scrapy.linkextractors import LinkExtractor
class LyricScrapperSpider(CrawlSpider):
    name = 'lyric_scrapper'
    allowed_domains = ['lirik.kapanlagi.com']
    start_urls = ['https://lirik.kapanlagi.com/lagu/a_id']
    rules = (Rule(LinkExtractor(allow=(), restrict_css=(".pagination2 ul li a",".col-lirik .div-horizontal2-list a", "div .letterLinksAnchor")), callback="parse_page", follow=True),)
    def parse_page(self, response):
        song = response.css('.col-lirik').extract_first()
        title= response.css('.head-lirik h5::text').extract_first()
        if len(title) > 0 and len(song) > 0:
scraped_info = {
            'song' : song,
            'title' : title,
        }
yield scraped_info

Посмотрим на эту часть:

start_urls = ['https://lirik.kapanlagi.com/lagu/a_id']
    rules = (Rule(LinkExtractor(allow=(), restrict_css=(".pagination2 ul li a",".col-lirik .div-horizontal2-list a", "div .letterLinksAnchor")), callback="parse_page", follow=True),)

Мы начнем с URL в start_urls. Чтобы определить начальный URL-адрес, мы должны найти страницу, содержащую индексный список лирики. Я обнаружил, что https://lirik.kapanlagi.com/lagu/a_id - это список индекса.

Сканер найдет свою следующую цель для очистки, найдя URL-адреса на текущей веб-странице. Чтобы сканер следил за нашей желаемой страницей, мы должны указать, какую часть или раздел веб-страницы должен видеть наш сканер. В этом случае нам нужно нацелить эту часть, показанную на изображении 2:

Нам понадобится часть или раздел, который мы хотим, проверив его HTML-код. Для меня я использовал Inspect Element (Firefox). Для этого веб-сайта мы ограничим поиск робота, который будет нацелен на (“.pagination2 ul li a”,”.col-lirik .div-horizontal2-list a”, “div .letterLinksAnchor”). Он будет сканировать веб-сайт до тех пор, пока не останется больше URL-адресов для сканирования (он также проверяет, был ли посещен URL-адрес).

Затем мы хотим извлечь текст и название песни с веб-страницы. Для этого нам нужно найти тег HTML, который их содержит (красный и синий на изображении 3).

song = response.css('.col-lirik').extract_first() 
title = response.css('.head-lirik h5::text').extract_first()

Для текста песни (я назвал его переменной "song") нам нужен HTML-код, потому что HTML-композиция этого сайта немного беспорядочная. Нам нужно почистить его позже.

Сохраните свой lyricscrapper.py. Затем откройте settings.py внутри папки.

Добавьте или раскомментируйте эти строки:

FEED_FORMAT = "csv"
FEED_URI = "scrape.csv"
DOWNLOAD_DELAY = 1 # important, sometimes you will get banned if you set it to 0.

Сохраните его, а затем выполните следующую команду на консоли:

scrapy crawl lyric_scrapper

Вуаля, наш сканер просканирует наш целевой сайт. Просто подождите, пока он не закончится, или заставьте его закончиться, если вам скучно. По окончании внутри папки будет сгенерировано scrape.csv. Вы можете открыть его с помощью инструментов для работы с электронными таблицами, чтобы увидеть его. Немного неряшливо, не правда ли? Как я сказал выше, нам нужно будет очистить текст лирики. Итак, перейдем к следующему шагу.

Очистить утилизированные данные

Пришло время очистить наши грязные данные. Поскольку мы хотим только сгенерировать текст, нам нужен только столбец песни из scrape.csv. Прежде чем мы начнем, я предлагаю использовать Python IDE, например Jupyter Notebook или Spyder, чтобы лучше видеть наши данные. В этой части мы будем использовать библиотеку pandas, чтобы увидеть наши данные в табличной форме.

Откройте свой код, а затем позвольте импортировать наши данные CSV и преобразовать их в тип фрейма данных (pd.DataFrame). Чтобы проверить текст песни, мы выберем 5 экземпляров. Обязательно поместите файл scrape.csv в папку кода нашего Python.

import pandas as pd
scrape_lyric = pd.read_csv('scrape.csv')
scrape_lyric.sample(5)

Во-первых, нам нужно убедиться, что в наших данных нет недостающих данных. Затем мы удаляем ненужные данные, если извлекаются неправильные страницы. В нашем случае мы обнаружим, что наша веб-страница с текстами песен должна содержать тег span. Поэтому удалите экземпляр, у которого нет тега span. Мы удалим экземпляр с текстом «Belum ada Lirik» (перевод: без текста).

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

scrape_lyric = scrape_lyric.dropna()
scrape_lyric = scrape_lyric[scrape_lyric.song.str.contains('span')]
scrape_lyric = scrape_lyric[~(scrape_lyric.song.str.contains('Belum Ada Lirik'))]

Проверьте размер вашего фрейма данных scrape_lyric.shape, у меня было 13791 строка. Было пропущено 6468 строк!

Мы увидим только столбец «песня». Посмотрев на столбец песни, мы увидим, что в тексте все еще есть HTML-тег. Нам нужно его очистить. Для этого мы будем использовать регулярное выражение.

Это регулярное выражение очистки предназначено только для нашего целевого веб-сайта. Если мы нацелены на другой веб-сайт, нам нужно увидеть, как выглядит шаблон HTML, и использовать соответствующее регулярное выражение для его очистки (или, возможно, нет необходимости очищать данные, если веб-сайт подходит для синтаксического анализа).

Вот регулярное выражение для очистки нашей очищенной веб-страницы:

def clean_text_lyric(lyric, max_length):
 lyric_sample = lyric.split('</span>')
 lyric_sample = lyric_sample[:-1]
    
 clean_song_lyric = ""
 for sentence in lyric_sample:
   if 'http' not in sentence:
      sentence = re.sub(r'<div .*>','',sentence)
      sentence = re.sub(r'<span .*>','',sentence)
      sentence = sentence.strip()
      if len(sentence) > 0:
        sentence = re.sub(r'[^a-zA-Z0-9<\/>\s]',' ', sentence)
        sentence = " <div> " + sentence + " </div> "
        sentence = re.sub(r'<div>\s+<br>','<br> <div> ', sentence)
        sentence = re.sub(r'(\d|\r|\t|\n)','',sentence)
        clean_song_lyric += sentence
        clean_song_lyric = ' <start> ' * (max_length-1) +                  clean_song_lyric
    return clean_song_lyric

Посмотрим по порядку:

lyric_sample = lyric.split('</span>')
lyric_sample = lyric_sample[:-1]

Если мы посмотрим на нашу извлеченную лирику, они отделяют свои стихи с помощью HTML-тега «<br>». 1 стих состоит из нескольких строк. Каждая строка разделяется HTML-тегом «</span>». Нам нужно разделить строку, разделив ее с помощью «</span>».

Теперь убираем HTML-тег (div, span)

sentence = re.sub(r'<div .*>','',sentence)
sentence = re.sub(r'<span .*>','',sentence)

Затем мы удалим весь символ, кроме [^a-zA-Z0–9<\/>\s]. Убираем escape-символ и лишние пробелы. Если вы не знакомы с регулярными выражениями, я предлагаю вам попробовать этот сайт для воспроизведения регулярных выражений.

sentence = re.sub(r'[^a-zA-Z0-9<\/>\s]',' ', sentence)
sentence = " <div> " + sentence + " </div> "
sentence = re.sub(r'<div>\s+<br>','<br> <div> ', sentence)
sentence = re.sub(r'(\d|\r|\t|\n)','',sentence)

Я ненавижу HTML-код этого сайта. Извлеченный текст песни иногда имеет URL-адрес внутри текста. Вот почему я поставил защиту от петель, чтобы убедиться, что внутри него нет URL.

После того, как мы очистим текст, мы хотим отметить начало и конец строки текста.

Для меня я использовал теги <div> и </div>, чтобы отметить начало и конец нашей лирики.

Мы не будем удалять тег <br>. Это тег для разделения каждого стиха.

Наконец, мы добавим тег «<start>» в начале текста рядом с желаемым max_length-1. Почему мы делаем это? Я скажу тебе позже.

Примените его к фрейму данных:

scrape_lyric['song'] = scrape_lyric['song'].apply(lambda x: clean_text_lyric(x))

Это текст желаемого формата текста, который мы хотим использовать.

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

После того, как мы закончим очистку данных, перейдем к предварительной обработке данных. Зачем нам это нужно? Входными данными нашей модели глубокого обучения является последовательность текста. Он не может читать текст в строковом режиме. Нам нужно закодировать все слово в нашем наборе данных в индексный номер, который отображает индексный номер в слово в одной горячей кодировке. Поскольку мы используем встраивание в keras, нам не нужно кодировать текст в одну горячую кодировку. Мы можем использовать карту индекса ключа, чтобы сопоставить слово с номером индекса в модели.

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

def generate_train_dataset(song_series, window):
    train_data = []
    train_label = []
    for song_string in song_series:
        song_arr = song_string.split()
        len_song_arr = len(song_arr)
        for i in range(0,len_song_arr-window+1):
            train_data.append(' '.join(song_arr[i:i+window-1]))
            train_label.append(song_arr[i+window-1])
    return np.array(train_data), np.array(train_label)

Посмотрите на изображение 6, чтобы представить себе, как будет работать generate_train_dataset функция. Он будет нарезать с начала до window-1 и добавит его в список train_data. Затем добавьте последний индекс в train_label list. Это называется скользящим окном, длина которого равна нашему параметру window. В этой статье мы установим окно равным 10.

Создаваемой нами функции в качестве входных данных требуется тип pandas.Series.

max_length = 10 #window
X, y = generate_train_dataset(scrape_lyric.song, sent_len=max_length)

Это сработало? Отлично, теперь мы будем использовать keras.preprocessing.text.Tokenizer library для создания карты ввода, которая будет отображать слово в индексный номер, выбранный функцией. Обязательно измените фильтр параметров, чтобы не включать ‘<’ и ‘>’.

pre = keras.preprocessing.text.Tokenizer(filters='!"#$%&()*+,-.:;=?@[\\]^_`{|}~\t\n')
pre.fit_on_texts(X.flatten()) # need to flatten the array

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

vocab_size = len(pre.word_index)

Преобразуем наши данные в последовательность индекса слов:

X = pre.texts_to_sequences(X)
y = pre.texts_to_sequences(y)

Мы закончили предварительную обработку наших входных данных. У меня было около 2 миллионов экземпляров.

Переходим к созданию модели.

Определите архитектуру глубокого обучения

Прежде чем мы углубимся в код и реализацию, давайте вспомним, что такое Deep Learning, Dense Layer, RNN, LSTM Layer и функция активации. Мы их вспомним.

Глубокое обучение

Глубокое обучение - это разновидность техники машинного обучения. По словам Йошуа Бенжио, он сказал: «Алгоритмы глубокого обучения стремятся использовать неизвестную структуру входного распределения для обнаружения хороших представлений, часто на нескольких уровнях, с изученными функциями более высокого уровня, определенными в терминах функций более низкого уровня. ».

Глубокое обучение узнает о представлении функций на основе данных. Нам не нужно извлекать особенность из данных. Он отличается от других алгоритмов машинного обучения, которые должны извлекать функции. Он состоит из нескольких слоев и сети, имитирующей человеческий мозг. У него много псевдонимов, таких как Deep Neural Network. Основной частью глубокой нейронной сети является алгоритм обратного распространения, который обновляет вес нашей модели, чтобы сделать ошибку минимальной с помощью алгоритма оптимизатора. Если хотите узнать больше, посетите этот сайт.

Встраивание

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

Есть несколько алгоритмов, с помощью которых можно встраивать слова. Есть:

Встраиваемый слой
Word2vec
Перчатка
Fastext
eLMo (НОВИНКА)

В нашей модели мы будем использовать слой встраивания. Он обновит вектор в соответствии с нашей моделью.

Плотный слой

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

RNN и LSTM

Рекуррентная нейронная сеть (RNN) - это уровень, который имеет внутреннюю память, поэтому он может запоминать информацию о последовательности входных данных. Связь между нейроном представляет собой последовательность ориентированного графа. Он запомнит информацию (вес) предыдущего нейрона и передаст ее текущему нейрону.

У использования RNN есть несколько недостатков. Он не может узнать «долгосрочные зависимости». Возникнет проблема «исчезающий градиент». Он больше не будет обновлять вес нейрона. Для решения этой проблемы используется долгосрочная краткосрочная память (LSTM).

LSTM - это решение проблемы RNN. он способен решить проблему долгосрочных зависимостей. LSTM может удалять или добавлять информацию в новый нейрон с помощью структур, называемых воротами. В LSTM есть 3 ворот: ворота забывания, входные ворота и выходные ворота. Они будут контролировать состояние нейрона. Для получения дополнительной информации вы можете посетить этот сайт.

Пакетная нормализация

Нормализовать выходные значения целевого слоя. У них будет средний выходной сигнал активации, равный нулю, и стандартное отклонение, равное единице. У этого есть несколько преимуществ, таких как ускорение скорости тренировок. См. Эту статью, если вы хотите узнать больше о BatchNormalization.

Функция активации

Он используется для определения того, активирован ли вывод слоя. Он отображает вывод в диапазон функции активации. Чтобы узнать подробности, посетите эту статью.

Архитектура

Готово вспомнить? давай перейдем к коду

Мы построим простую архитектуру Deep Network. Он состоит из встраиваемого слоя, слоя LSTM и плотного слоя с категориальной перекрестной энтропией и активацией softmax на выходе. Изображение 7 - это визуализация нашей архитектуры, которую мы хотим создать.

model = Sequential()
e = Embedding(vocab_size,100 ,input_length=max_length-1, trainable=True)
model.add(e)
model.add(keras.layers.BatchNormalization())
model.add(keras.layers.Bidirectional(keras.layers.CuDNNLSTM(100)))
model.add(keras.layers.BatchNormalization())
model.add(Dense(100, activation='relu'))
model.add(keras.layers.BatchNormalization())
model.add(Dense(vocab_size+1, activation='softmax')) 
# vocab_size +1 to avoid out of bound
# compile the model
model.compile(optimizer='adam', loss='categorical_crossentropy')

В этой статье мы будем использовать модель с указанным гиперпараметром. Конечно, вы можете настроить гиперпараметр нашей модели. Для простоты мы будем использовать только 1 bi-LSTM и 1 плотный слой. Мы используем BatchNormalization, чтобы ускорить обучение. Если мы используем графический процессор, мы должны использовать CuDNNLSTM для ускорения скорости обучения.

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

Модель поезда

Прежде, чем мы подгоним или обучим нашу модель. У нас есть проблема, которую нужно решить. Если мы увидим наш voiceab_size, он содержит около 45 000 уникальных слов. В keras мы должны закодировать метку поезда в одну горячую кодировку [0 0 0… 1… 0]. Если мы изменим все метки нашего поезда на одну горячую кодировку, это вызовет MemoryError (требуется 45,000 * 2 миллиона * 4 байта памяти. Невозможно сохранить это в памяти). Поэтому нам нужно изменить метку поезда на одно горячее кодирование в пакете.

def batch_data(start,end):
    global X,y,y_input, X_input
    X_input = np.array(X)[start:end]
    y_input = np.array(y)[start:end]
    y_input = keras.utils.to_categorical(y_input,vocab_size+1)
max_epoch = 40
instance_max = len(X)
batch_size = 10000
for i in range(max_epoch):
    start_idx_counter = 0
    while start_idx_counter < instance_max:
        batch_data(start_idx_counter, min(start_idx_counter+batch_size,instance_max))
        model.fit(X_input, y_input, epochs=1, batch_size=64) 
        start_idx_counter += batch_size

Мы определим 10000 как размер нашей партии. Не стесняйтесь уменьшать или увеличивать размер по своему желанию. Подгоняем нашу модель к 40 эпохам (итерация). Выполните код! Batch_size в методе подгонки также можно настроить.

Ждать его!!

На обучение моей модели на GPU ушел 1 день. Если вы не хотите ждать так долго, уменьшите max_epoch.

Выполнено? Не забудьте сохранить модель и токенизатор. Хотите подождать еще день, чтобы обучить нашу модель? Нет? Не забудьте сохранить модель!

model.save('lyric_gen_model.h5')

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

import pickle
pickle.dump( pre, open( "tokenizer_pre_lyric.p", "wb" ) )

Были сделаны. Создадим нашу лирику !!!

Создать текст

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

model = keras.models.load_model('lyric_gen_model.h5')
pre = pickle.load( open( "tokenizer_pre_lyric.p", "rb" ) )

Затем нам нужно сначала предварительно обработать наш ввод.

def preprocess_predict(X):
    X = pre.texts_to_sequences(X)
    return X

В нашей статье мы вставили токен «‹start›» в начало текста. Мы делаем это, чтобы отметить начало текста песни. Если мы хотим сгенерировать без начальных слов. Мы можем сделать это:

seed = "<start> " * (max_length-1)

В качестве альтернативы вы также можете включить несколько начальных слов.

seed = "<start> " * (max_length-3)
seed = "<div> love"

Мы должны определить функцию, которая поможет нам создавать тексты песен.

def is_word_in_dict(words, word_idx):
    for word in words.split():
        if word not in word_idx:
            return False
    return True
def generate_song_by_model(model, idx_word, X_sent, word_idx, total_classes, word_generated=80):
    string_returned = X_sent
    if is_word_in_dict(X_sent, word_idx):
        X = np.array(preprocess_predict([X_sent]))
        counter = 1

 
        for i in range(word_generated):
           y_pred = model.predict(X)
           rnd_choice = np.random.choice(range(0,total_classes),size=1,replace=False, p=y_pred[0])
           word_predict = idx_word[rnd_choice[0]]
           string_returned += " " + word_predict
           X = ' '.join(string_returned.split()[counter:])
           X = np.array(preprocess_predict([X]))
           counter += 1
  return string_returned

В этой функции мы будем предсказывать слово на основе нашего начального числа (переменная X_sent в нашей функции создания). Мы берем токены размера окна length-1 в качестве входных данных нашей модели, и модель предсказывает следующий токен. В следующем цикле он примет в модель предсказанные выходные данные и токены size-length-2. Он будет повторяться до конца, который мы установили. Мы получим случайное слово на основе распределения вероятностей, полученного на выходе softmax. Если вы используете Jupyter Notebook, используйте эту команду для отображения сгенерированного текста текста.

from IPython.display import HTML
generated_lyric = generate_song_by_model(model, pre.index_word, seed, max_length, pre.word_index, vocab_size+1,loop_count=50)
HTML(generated_lyric)

Он сгенерирует 50 новых токенов / слов (включая теги). Сгенерированный текст должен иметь HTML-теги ‹div› и ‹br›, которые служат разделителями строк и стихов. Мы используем функцию HTML в IPython.display для очистки тега на дисплее. Вот несколько примеров нашей сгенерированной лирики.

я пытаюсь отвезти тебя домой

я свет одного

Однажды я могу улететь

кто смотрел мои руки вниз

и один, если я не в порядке

вы начинаете путь к

В этом сформировалась лирика. Очень последовательно использовать английское слово. Это неплохо, хотя здесь есть какое-то непонятное значение. Наш результат основан на случайности. Если ваша модель научилась меньше, она может создавать плохие тексты!

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

Вот еще одна порожденная лирика.

дара кау бертанья шиапа намаму

Ян Сенюм Тангисму

пасти пахит ди аяхку

pada bermula dekat di pandang luka

Дэн Семуа Карена Чинтаму

терсимпан нама джива ку масих ада ди джендела хатиму

Ку Так Ингин Сендири

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

Заключение

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

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

Послесловие

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

Приносим извинения за орфографические ошибки, грамматику и неэффективный код.

О, я упомянул часть 1? Да, я планирую улучшить этот генератор текстов, сделав архитектуру более сложной (возможно, используя GAN), используя другое встраивание и гиперпараметры.

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

До встречи в следующей статье!

Создание индонезийской лирики с использованием глубокого обучения - часть первая