Практическая реализация концепций НЛП, машинного обучения без учителя и глубокого обучения на немаркированных текстовых данных.

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

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

  1. Как собирать данные из Twitter через Twitter API и пакет Tweepy Python
  2. Как эффективно читать и очищать большой набор текстовых данных с помощью pandas
  3. Как предварительно обработать текстовые данные с помощью основных техник НЛП и сгенерировать функции
  4. Как классифицировать немаркированные текстовые данные
  5. Как обучать, компилировать, настраивать и оценивать модели глубокого обучения в Keras

Найдите мои записные книжки Jupyter с кодом Python в моем GitHub здесь.

Закатайте рукава, у нас много работы, давайте приступим ...

Данные

На момент создания этого проекта выборы в США 2020 были не за горами, и было целесообразно провести анализ настроений твитов, связанных с предстоящими выборами, чтобы узнать о том, какие мнения и темы обсуждаются в мире Twitter примерно за 2 недели. до дня выборов. Twitter - отличный источник неотфильтрованных мнений, в отличие от типичных отфильтрованных новостей, которые мы видим из основных СМИ. Таким образом, мы собираемся создать собственный набор данных, собирая твиты из Twitter с помощью Twitter API и пакета Python Tweepy.

Шаг 1. Сбор данных

Предпосылки

Прежде чем приступить к потоковой передаче данных из Twitter, вы должны иметь следующее:

  1. Учетная запись Twitter и потребительские ключи Twitter API (ключ токена доступа, секретный ключ токена доступа, ключ потребителя и секретный ключ потребителя)
  2. Пакет Tweepy установлен в ваш ноутбук Jupyter

Настройка учетной записи Twitter и получение ключей потребителя Twitter API выходит за рамки этой статьи. Если вам понадобится помощь, прочтите этот пост.

Tweepy можно установить с помощью pip install в ноутбуке Jupyter, следующий однострочный код поможет.

# Install Tweepy
!pip install tweepy

После установки импортируйте пакет в свой ноутбук.

1.1 Настройка конвейера потоковой передачи данных

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

  1. Настройте свои потребительские ключи Twitter API
  2. Настроить обработчик авторизации Twitter API
  3. Напишите настраиваемую функцию, которая прослушивает и транслирует живые твиты
# Twitter API consumer keys
access_token = "  insert your key here  "
access_token_secret = "  insert your key here  "
consumer_key = "  insert your key here  "
consumer_secret = "  insert your key here  "
# Twitter API authorization
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
# Custom function that streams data from Twitter (20,000 tweets at most per instance)
class MyStreamListener(tweepy.StreamListener):
    """Function to listen and stream Twitter data"""
    def __init__(self, api=None):
        super(MyStreamListener, self).__init__()
        self.num_tweets = 0
        self.file = open("tweets.txt", "w")
def on_status(self, status):
        tweet = status._json
        self.file.write( json.dumps(tweet) + '\n' )
        self.num_tweets += 1
        if self.num_tweets < 20000: 
            return True
        else:
            return False
        self.file.close()
def on_error(self, status):
        print(status)

1.2 Начать трансляцию живых твитов

Теперь, когда среда настроена, вы готовы начать потоковую передачу твитов из Twitter. Перед тем как это сделать, определите несколько ключевых слов, которые вы хотели бы использовать для сбора соответствующих твитов, представляющих для вас интерес. Поскольку я буду транслировать твиты, связанные с выборами в США, я выбрал несколько релевантных ключевых слов, таких как «выборы в США», «Трамп», «Байден» и т. Д.

Наша цель состоит в том, чтобы собрать не менее 400000 твитов, чтобы сделать их достаточно большими текстовыми данными, и собрать все это за один раз требует больших вычислительных затрат. Таким образом, я буду настраивать конвейер таким образом, чтобы эффективно передавать данные по частям. Обратите внимание на приведенную выше пользовательскую функцию, она будет прослушивать и транслировать до 20 000 твитов максимум в каждом блоке. Таким образом, чтобы собрать более 400 000 твитов, нам потребуется запустить не менее 20 чанков.

Вот как код ищет блок, который прослушивает и передает живые твиты в pandas DataFrame:

# Listen and stream live tweets
listener = MyStreamListener()
stream = tweepy.Stream(auth, listener)
stream.filter(track = ['US Election', 'election', 'trump', 'Mike Pence', 'biden', 'Kamala Harris', 'Donald Trump', 'Joe Biden'])
# Read the tweets into a list
tweets_data_path = 'tweets.txt'
tweets_data=[]
tweets_file_1 = open(tweets_data_path, 'r')
# Read in tweets and store in list: tweets_data
for line in tweets_file_1:
    tweet = json.loads(line)
    tweets_data.append(tweet)
# Close connection to file
tweets_file_1.close()
# Print the keys of the first tweet dict
print(tweets_data[0].keys())
# Read the data into a pandas DataFrame
names = tweets_data[0].keys()
df1 = pd.DataFrame(tweets_data, columns= names)

Как уже упоминалось, чтобы собрать 400000 твитов, вам нужно будет запустить приведенный выше код не менее 20 раз и сохранить собранные твиты в отдельном фрейме данных pandas, который позже будет объединен для объединения всех твитов в единый набор данных.

1.3 Объедините все блоки данных в единый набор данных

# Concatenate dataframes into a single pandas dataframe
list_of_dataChunks = [df1, df2, df3, df4, df5, df6, df7, df8, df9, df10, df11, df12, df13, df14, df15, df16, df17, df18, df19, df20]
df = pd.concat(list_of_dataChunks, ignore_index=True)
# Export the dataset into a CSV file
df.to_csv('tweets.csv', index=False)

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

Я пожертвовал созданный мной набор данных и сделал его общедоступным в Kaggle.

Шаг 2. Обработка данных

В этом разделе мы очистим только что собранные данные. Прежде чем данные можно будет визуализировать, набор данных необходимо очистить и преобразовать в формат, который можно было бы эффективно визуализировать. Учитывая набор данных с 440 000 строками, необходимо найти эффективный способ его чтения и очистки. Для этого можно использовать атрибут pandas chunksize для чтения данных из файла CSV в блок данных pandas по частям. Кроме того, мы можем указать имена столбцов, которые нам интересно читать, в отличие от чтения набора данных со всеми его столбцами. Благодаря размеру блока и меньшему количеству представляющих интерес столбцов большой набор данных может быть достаточно эффективно и быстро считан в фрейм данных без необходимости использования других альтернатив, таких как распределенные вычисления с PySpark в кластере.

Чтобы преобразовать набор данных в форму, необходимую для визуализации, будут применены следующие основные методы НЛП:

  1. Извлеките только твиты на английском языке
  2. Удалите дубликаты, если они есть
  3. Удалите отсутствующие значения, если таковые имеются
  4. Токенизировать (разбивать твиты на отдельные слова)
  5. Преобразуйте слова в нижний регистр
  6. Удалить знаки препинания
  7. Удалить игнорируемые слова
  8. Удалите URL-адреса, слово «твиттер» и другие сокращения.

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

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

Давайте посмотрим на все это в действии ...

# Function to tokenize the tweets
def custom_tokenize(text):
    """Function that tokenizes text"""
    from nltk.tokenize import word_tokenize
    if not text:
        print('The text to be tokenized is a None type. Defaulting to blank string.')
        text = ''
    return word_tokenize(text)
# Function that applies the cleaning steps
def clean_up(data):
    """Function that cleans up the data into a shape that can be further used for modeling"""
    english = data[data['lang']=='en'] # extract only tweets in english language
    english.drop_duplicates() # drop duplicate tweets
    english['text'].dropna(inplace=True) # drop any rows with missing tweets
    tokenized = english['text'].apply(custom_tokenize) # Tokenize tweets
    lower_tokens = tokenized.apply(lambda x: [t.lower() for t in x]) # Convert tokens into lower case
    alpha_only = lower_tokens.apply(lambda x: [t for t in x if t.isalpha()]) # Remove punctuations
    no_stops = alpha_only.apply(lambda x: [t for t in x if t not in stopwords.words('english')]) # remove stop words
    no_stops.apply(lambda x: [x.remove(t) for t in x if t=='rt']) # remove acronym "rt"
    no_stops.apply(lambda x: [x.remove(t) for t in x if t=='https']) # remove acronym "https"
    no_stops.apply(lambda x: [x.remove(t) for t in x if t=='twitter']) # remove the word "twitter"
    no_stops.apply(lambda x: [x.remove(t) for t in x if t=='retweet']) # remove the word "retweet"
    return no_stops
# Read and clean the data
warnings.filterwarnings("ignore")
use_cols = ['text', 'lang'] # specify the columns
path = 'tweets.csv' # path to the raw dataset
data_iterator = pd.read_csv(path, usecols=use_cols, chunksize=50000)
chunk_list = []
for data_chunk in data_iterator:
    filtered_chunk = clean_up(data_chunk)
    chunk_list.append(filtered_chunk)
tidy_data = pd.concat(chunk_list)

Размер блока в данном случае составляет 50 000, и именно так панды будут читать 50 000 твитов в каждом блоке и применять к ним шаги очистки перед чтением следующего пакета и т. Д. И т. Д.

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

# Explort the tidy data to json file for ease of use in the next steps
tidy_data.to_json('tidy_tweets.json', orient='table')

Вот как выглядят аккуратные данные:

Шаг 3: Исследовательский анализ данных (визуализация)

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

  1. Количество слов в каждом твите
  2. Средняя длина слова в твите
  3. Юниграмма
  4. Биграмма
  5. Триграмма
  6. Wordcloud

Похоже, что количество слов в каждом твите варьируется от 1 до 19 слов и в среднем составляет от 10 до 12 слов.

Среднее количество символов в слове в твите составляет от 3 до 14 символов и в среднем составляет от 5 до 7 символов. Люди, вероятно, выбирают короткие слова, чтобы выразить свое мнение наилучшим образом, в пределах установленного Twitter ограничения в 280 символов.

Юниграмма

Как и ожидалось, слова «трамп» и «байден» преобладают в твитах, связанных с выборами в США 2020 года, которые были отправлены в период с 15 по 16 октября.

Биграмма (наиболее часто встречающаяся пара последовательных слов)

Триграмма (наиболее часто встречающаяся последовательность из трех слов)

Wordcloud

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

# Convert tokens into format required for lemmatization
from nltk.corpus import wordnet
def get_wordnet_pos(word):
    """Map POS tag to first character lemmatize() accepts"""
    tag = nltk.pos_tag([word])[0][1][0].upper()
    tag_dict = {"J": wordnet.ADJ,
                "N": wordnet.NOUN,
                "V": wordnet.VERB,
                "R": wordnet.ADV}
return tag_dict.get(tag, wordnet.NOUN)
# Lemmatize tokens
lemmatizer = WordNetLemmatizer()
tidy_tweets['lemmatized'] = tidy_tweets['text'].apply(lambda x: [lemmatizer.lemmatize(word, get_wordnet_pos(word)) for word in x])
# Convert the lemmatized words back to the text format
tidy_tweets['tokens_back_to_text'] = [' '.join(map(str, l)) for l in tidy_tweets['lemmatized']]

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

# Explort the lemmatized data to json file for ease of use in the next steps
tidy_tweets.to_json('lemmatized.json', orient='table')

Подход

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

  1. Обозначьте набор данных алгоритмом кластеризации k-средних
  2. Обучите модели глубокого обучения предсказывать категории твитов
  3. Оцените модели и определите потенциальные улучшения

Шаг 4. Маркировка немаркированных текстовых данных и предварительная обработка.

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

Существует множество различных способов категоризации немаркированных текстовых данных, и такие методы включают, помимо прочего, использование SVM, иерархическую кластеризацию, косинусное подобие и даже Amazon Mechanical Turk. В этом примере я покажу вам еще один более простой, возможно, не самый точный способ быстрого и грязного способа категоризации текстовых данных. Для этого я сначала проведу анализ настроений с VADER, чтобы определить, являются ли твиты положительными, отрицательными или нейтральными. Затем я буду использовать простой алгоритм кластеризации k-средних для кластеризации твитов на основе вычисленного составного значения, полученного из значений того, насколько положительными, отрицательными и нейтральными являются твиты.

4.1 Создайте настроение

Давайте сначала посмотрим на набор данных

Столбец «tokens_back_to_text» - это лемматизированные токены, преобразованные обратно в текстовый формат, и я собираюсь использовать этот столбец из аккуратного набора данных для создания настроений с помощью SenitmentIntensityAnalyzer из пакета VADER.

# Extract lemmatized text into a list
tweets = list(df['tokens_back_to_text'])
# Create sentiments with SentimentIntensityAnalyzer
from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer 
sid = SentimentIntensityAnalyzer()
sentiment = [sid.polarity_scores(tweet) for tweet in tweets]

Вот как выглядят первые 5 рядов настроений

4.2 Пометьте немаркированные данные с помощью кластеризации k-средних

Теперь я буду использовать столбец «составной» из приведенного выше фрейма данных и введу его в алгоритм кластеризации k-средних, чтобы классифицировать твиты с 0 или 1, представляющими «отрицательное» или «положительное» настроение соответственно. То есть я помечу твиты с соответствующим составным значением больше и равным 0,05 как положительное, а значение меньше 0,05 будет помечено как отрицательное. Здесь нет жесткого правила, это просто то, как я поставил свой эксперимент.

Вот как вы можете реализовать задание текстовой маркировки с помощью алгоритма кластеризации k-средних из scikit-learn на python. Не забудьте указать одинаковый индекс для меток и исходного фрейма данных, в котором у вас есть твиты / тексты.

# Tag the tweets with labels using k-means clustering algorithm
from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters=2, random_state=0).fit(compound)
labels = pd.DataFrame(kmeans.labels_, columns=['label'], index=df.index)

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

Кроме того, мы могли бы также идентифицировать темы твитов из каждой из категорий с помощью мощного алгоритма НЛП под названием «Скрытое распределение Дирихле», которое могло бы обеспечить интуитивное понимание тем в отрицательных и положительных твитах. Я покажу это в отдельной статье позже. А пока давайте воспользуемся категориями 0 и 1 для этого упражнения. Итак, теперь мы успешно преобразовали нашу проблему в задачу контролируемого обучения, и теперь мы перейдем к обучению моделей глубокого обучения, используя наши теперь помеченные текстовые данные.

Шаг 5: моделирование

У нас есть довольно большой набор данных, содержащий более 400 000 твитов с более чем 60 000 уникальных слов. Обучение RNN с несколькими скрытыми слоями на таком большом наборе данных требует больших вычислительных затрат и может занять дни (если не недели), если вы попытались обучить их на ЦП. Одним из распространенных подходов к обучению моделей глубокого обучения является использование машин, оптимизированных для графического процессора, для повышения производительности обучения. В этом упражнении мы собираемся использовать экземпляр Amazon SageMaker p2.xlarge, который поставляется с предварительно загруженной серверной частью TensorFlow и CUDA. Мы будем использовать интерфейс Keras для TensorFlow.

Приступим, применим следующие шаги.

Шаги обучения

  1. Токенизация, заполнение и упорядочение набора данных
  2. Сбалансируйте набор данных с помощью SMOTE
  3. Разделите набор данных на обучающий и тестовый наборы
  4. Обучить модели SimpleRNN и LSTM
  5. Оценить модели

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

tweets.head()

5.1 Токенизация, заполнение и упорядочение набора данных

# prepare tokenizer tokenizer = Tokenizer() tokenizer.fit_on_texts(tweets)
# integer encode the documents
sequences = tokenizer.texts_to_sequences(tweets)
# pad documents to a max length of 14 words maxlen = 14 X = pad_sequences(sequences, maxlen=maxlen)

5.2 Сбалансируйте несбалансированные данные с помощью SMOTE

from imblearn.over_sampling import SMOTE
from imblearn.under_sampling import RandomUnderSampler
from imblearn.pipeline import Pipeline
# define pipeline
over = SMOTE(sampling_strategy=0.5)
under = RandomUnderSampler(sampling_strategy=0.8)
steps = [('o', over), ('u', under)]
pipeline = Pipeline(steps=steps)
# transform the dataset
X, y = pipeline.fit_resample(X, labels['label'])
# One-hot encoding of labels
from keras.utils.np_utils import to_categorical
y = to_categorical(y)

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

5.3 Разделение данных на обучающие и тестовые наборы

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

# Split the dataset into train and test sets
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=43)

5.4 Обучение RNN

В этом разделе я покажу вам, как реализовать несколько вариантов архитектуры глубокого обучения RNN, трехуровневую архитектуру SimpleRNN и трехуровневую архитектуру LSTM. Для функции активации по умолчанию установлено значение «tanh» как для слоев SimpleRNN, так и для слоев LSTM, поэтому оставим значение по умолчанию. Я буду использовать все 65 125 уникальных слов в качестве размера словаря, ограничу максимальную длину каждого ввода до 14 слов, поскольку это согласуется с максимальной длиной слова в твите, и установлю размер вывода матрицы встраивания равным 32.

SimpleRNN

Слои отсева будут использоваться для обеспечения соблюдения условий регуляризации для контроля переобучения. Поскольку мой набор данных помечен как двоичный класс, я буду использовать двоичную кроссентропию в качестве функции потерь. С точки зрения оптимизатора, оптимизатор Adam - хороший выбор, и я буду включать точность в качестве показателя. Я проведу 10 эпох на обучающем наборе, в котором 70% обучающего набора будут использоваться для обучения модели, а оставшиеся 30% будут использоваться для проверки. Это не следует путать с тестовым набором, который мы держали подальше.

# SimpleRNN
model = Sequential()
model.add(Embedding(input_dim = vocab_size, output_dim = output_dim, input_length = maxlen, embeddings_constraint=maxnorm(3)))
model.add(SimpleRNN(output_dim=output_dim, return_sequences=True, kernel_constraint=maxnorm(3)))
model.add(Dropout(0.2))
model.add(SimpleRNN(output_dim=output_dim, return_sequences=True, kernel_constraint=maxnorm(3)))
model.add(Dropout(0.2))
model.add(SimpleRNN(output_dim=output_dim))
model.add(Dense(2,activation='softmax'))

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

Результаты модели SimpleRNN показаны следующим образом - 10 эпох:

LSTM

Трёхслойная модель LSTM будет обучаться с выпадающими слоями. Я проведу 10 эпох на обучающем наборе, в котором 70% обучающего набора будут использоваться для обучения модели, а оставшиеся 30% будут использоваться для проверки. Это не следует путать с тестовым набором, который мы держали подальше.

# LSTM
model.add(Embedding(input_dim = vocab_size, output_dim = output_dim, input_length = maxlen, embeddings_constraint=maxnorm(3)))
model.add(LSTM(output_dim=output_dim, return_sequences=True, kernel_constraint=maxnorm(3)))
model.add(Dropout(0.2))
model.add(LSTM(output_dim=output_dim, return_sequences=True, kernel_constraint=maxnorm(3)))
model.add(Dropout(0.2))
model.add(LSTM(output_dim=output_dim, kernel_constraint=maxnorm(3)))
model.add(Dense(2,activation='softmax'))

Сводка модели отображается следующим образом:

Результаты модели LSTM показаны следующим образом - 10 эпох:

Шаг 6: оценка модели

Теперь давайте построим график поведения моделей во времени и посмотрим на их точность и потери за 10 эпох.

SimpleRNN: точность

SimpleRNN: потеря

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

LSTM: точность

LSTM: потеря

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

Заключение

В этом проекте я попытался продемонстрировать, как настроить конвейер глубокого обучения, который прогнозирует настроения твитов, связанных с выборами в США 2020 года. Для этого я сначала создал свой собственный набор данных, очищая необработанные твиты через Twitter API и пакет Tweepy.

Более 440 000 твитов были переданы через Twitter API и сохранены в CSV-файле. После обработки и визуализации данных был использован традиционный алгоритм кластеризации, в данном случае кластеризация k-средних, чтобы пометить твиты двумя разными метками, представляющими положительные или отрицательные настроения. То есть проблема была преобразована в проблему контролируемого обучения до обучения моделей глубокого обучения с данными. Затем набор данных был разделен на обучающий и тестовый наборы.

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

Рекомендации:

  • Найдите другой подход или другой алгоритм обучения для маркировки набора данных
  • Попробуйте Amazon Mechanical Turk или Ground Truth, чтобы пометить набор данных
  • Попробуйте разные архитектуры RNN
  • Выполните более продвинутую настройку гиперпараметров архитектур RNN
  • Выполните перекрестную проверку
  • Сделайте проблему данных многоклассовой

Навыки, приобретенные в ходе этого проекта / учебного пособия:

  1. Как эффективно собирать данные из Twitter через Tweepy и Twitter API
  2. Как эффективно работать с большим набором данных

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

4. Как применить основные концепции и техники НЛП к текстовым данным.

Опять же, найдите мои записные книжки Jupyter с кодом Python в моем GitHub здесь, и давайте подключимся к LinkedIn.

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

Спасибо!

Ссылки и полезные материалы в Интернете: