Implementasi CNN Untuk Klasifikasi Teks Menggunakan Tensorflow

Oleh Denny Britz diterjemahkan oleh Moch. Ari Nasichuddin*

Dalam artikel ini kita akan mengimplementasikan model yang mirip dengan paper Kim Yoon tentang Klasifikasi Kalimat Menggunakan Convolutional Neural Network. Model tersebut menunjukkan kinerja klasifikasi yang baik dalam melakukan tugas klasifikasi teks (seperti analisis sentimen) dan semenjak itu menjadi standar dasar arsitektur baru dalam melakukan klasifikasi teks.

Saya mengansumsikan Anda telah familiar dengan dasar Convolutional Neural Network yang diaplikasikan dalam NLP. Jika tidak, saya merekomendasikan untuk terlebih dahulu membaca artikel tentang Memahami Convolutional Neural Network untuk NLP untuk mendapatkan dasar-dasar yang diperlukan.

Data dan Preprocessing

Dalam artikel ini kita akan menggunakan dataset dari data ulasan film Rotten Tomatoes — salah satu dataset yang juga digunakan di paper aslinya. Dataset ini berisi 10,662 contoh kalimat ulasan film, separo positif dan separo negatif. Dataset berisi kosakata dengan ukuran 20k. Sekadar catatan, data ini cukup kecil untuk menguji overfit dari sebuah model. Pun dataset tersebut tidak disertai dengan pembagian train/set yang resmi, jadi kita hanya menggunakan 10% dari data. Di dalam paper menuliskan hasil 10-fold cross-validation data.

Saya tidak akan membuat kode untuk pre-processing pada artikel ini, tetapi data pre-processing tersedia di Github dengan karakteristik:

1. Memuat kalimat positif dan negatif dari file data mentah (raw data).
2. Membersikan teks data menggunakan kode yang sama dari paper asli.
3. Setiap kalimat mempunyai panjang maksimum 59. Kami menambahkan tanda<PAD> untuk semua kalimat guna menjadikannya 59 kata. Mengeset kalimat dengan panjang yang sama berguna ketika kita ingin melakukan efinsiensi sekumpulan data. Setiap contoh di kumpulan data harus mempunyai panjang yang sama.
4. Membangun indeks kosakata dan memetakan setiap kata menjadi bilangan bulat (integer) antara 0 dan 18.765 (ukuran kosakata). Setiap kata menjadi vektor dari integer.

Model

Network yang kita buat dalam artikel ini kira-kira akan seperti ini:

Layer pertama menyimpan kata-kata dalam sebuah low-dimensional vector. Layer selanjutnya menjalankan convolutions menggunakan multiple filter sizes. Sebagai contoh melakukan pergeseran 3, 4 atau 5 kata dalam satu waktu. Selanjutnya, kita melakukan max-pool hasil dari layer convolutional ke dalam sebuah long feature vector, menambahkan dropout regularization, dan mengklasifikasikan hasil menggunakan softmax layer.

Karena artikel ini bertujuan sebagai bahan pembelajaran, saya memutuskan untuk menyederhanakan model dari paper yang asli.

• Kita tidak akan menggunakan pre-trained word2vec vectors untuk kata yang kita simpan. Sebagai gantinya, kita belajar menyimpan dari scratch.
• Kita tidak akan memaksakan L2 norm constraints pada bobot vektor. Analisis Sensitifitas dari (dan panduan praktisi) Convolutional Neural Network menemukan bahwa constraints mempunyai efek kecil pada hasil akhir.
• Percobaan dari paper yang asli dengan 2 input data channels — static dan non-static word vectors. Namun untuk kali ini kita akan menggunakan 1 channel.

Hal ini relatif mudah (hanya beberapa baris kode) untuk menambahkan extentions di atas pada sebuah kode. Mari kita coba pada akhir dari artikel ini.

Mari kita coba!

Implementasi

Untuk memungkinkan berbagai konfigurasi hyperparameter kita meletakkan kode pada kelas TextCNN untuk generating grafik model di fungsi init.

import tensorflow as tf
import numpy as np
 
class TextCNN(object):
    """
    A CNN for text classification.
    Uses an embedding layer, followed by a convolutional, max-pooling and softmax layer.
    """
    def __init__(
      self, sequence_length, num_classes, vocab_size,
      embedding_size, filter_sizes, num_filters):
        # Implementation...

Untuk menginisiasi kelas kita akan memberikan argumen sebagai berikut:

• sequence_length — Panjang dari kalimat. Ingat bahwa kita akan mengeset semua kalimat mempunyai panjang yang sama (59 untuk dataset kita).
• num_classes — Jumlah dari kelas di output layer, 2 dalam kasus kita (positif dan negatif).
• vocab_size — Ukuran dari kosakata. Ini diperlukan untuk mendefinisikan ukuran dari embedding layer, yang akan memiliki bentuk [vocabulary_size, embedding_size].
• embedding_size — Dimensi dari embeddings.
• filter_sizes — Jumlah kata yang kita inginkan untuk convolutional filters. Kita akan memiliki num_filters untuk setiap ukuran spesifik. Sebagai contoh, [3, 4, 5] yang artinya kita akan mempunyai filter slide 3, 4 dan 5 untuk masing-masing kata, sebagai total dari 3 * num_filters filter.
• num_filters — Jumlah filter untuk setiap ukuran filter (lihat di atas).

Input Placeholders

Kita mulai dengan mendefinisikan input data yang akan kita masukkan ke network:

# Placeholders for input, output and dropout
self.input_x = tf.placeholder(tf.int32, [None, sequence_length], name="input_x")
self.input_y = tf.placeholder(tf.float32, [None, num_classes], name="input_y")
self.dropout_keep_prob = tf.placeholder(tf.float32, name="dropout_keep_prob")

tf.placeholder membuat variabel placeholder yang kita masukkan ke network ketika dieksekusi pada saat train atau test time. Argumen kedua merupakan bentuk dari input tensor. None berarti bahwa panjang dari dimensi bisa apa saja. Dalam kasus ini, dimensi pertama adalah batch size.

Probabilitas berguna untuk mempertahankan neuron dalam layer dropout, yang juga dilakukan input ke network karena kita mengaktifkan dropout selama masa training. Setelah itu kita menonaktifkannya ketika mengevaluasi model (nanti akan dijelaskan lebih lanjut).

Embedding Layer

Layer pertama kita definisikan sebagai embedding layer, yang memetakan indeks kata kosakata dalam representasi vektor dimensi rendah. Ini pada dasarnya merupakan tabel yang dipelajari dari data.

with tf.device('/cpu:0'), tf.name_scope("embedding"):
    W = tf.Variable(
        tf.random_uniform([vocab_size, embedding_size], -1.0, 1.0),
        name="W")
    self.embedded_chars = tf.nn.embedding_lookup(W, self.input_x)
    self.embedded_chars_expanded = tf.expand_dims(self.embedded_chars, -1)

Kita menggunakan sepasang fitur baru di sini, jadi mari kita lihat:

• tf.device(“/cpu:0”) untuk memaksa operasi untuk mengeksekusinya di CPU. By default Tensorflow akan mencoba untuk menempatkan operasinya pada GPU jika tersedia, namun untuk implementasi saat ini tidak menggunakan GPU .
• tf.name_scoper untuk membuat name scope baru dengan nama “embedding”. Scope ini akan menambah semua operasi menuju top-level node yang disebut “embedding” jadi Anda akan mendapatkan hirarki yang bagus ketika memvisualisasikan pada network Anda di TensorBoard.

W adalah matrik embedding yang akan dipelajari selama training. Kita menginisialisasinya menggunakan sebuah random uniform distribution. tf.nn.embedding_lookup membuat operasi actual embedding. Hasil dari operasi embedding adalah 3 dimensi tensor of shape [None, sequence_length, embedding_size].

TensofFlow melakukan operasi convolutional conv2d dengan mengharapkan dimentional tensor dengan dimensi sesuai dengan batch, width, height dan channel. Hasil dari embedding tidak mengandung channel dimension, jadi kita akan menambahkan manual, dengan meninggalkan layer of shape [None, sequence_length, embedding_size, 1].

Convolution dan Max-Pooling Layers

Sekarang kita siap untuk membangun sebuah layer convolutional yang diikuti oleh max-pooling. Ingat, kita menggunakan filter pada setiap ukuran yang berbeda. Karena setiap convolutional memproduksi banyak tensor dari bentuk yang berbeda, kita memerlukan untuk melakukan iterasi pada banyak tensor tersebut. Membuat layer pada setiap tensor, dan kemudian menggabungkan hasilnya ke dalam sebuah fitur vektor yang besar.

pooled_outputs = []
for i, filter_size in enumerate(filter_sizes):
with tf.name_scope("conv-maxpool-%s" % filter_size):
# Convolution Layer
filter_shape = [filter_size, embedding_size, 1, num_filters]
W = tf.Variable(tf.truncated_normal(filter_shape, stddev=0.1), name="W")
b = tf.Variable(tf.constant(0.1, shape=[num_filters]), name="b")
conv = tf.nn.conv2d(
self.embedded_chars_expanded,
W,
strides=[1, 1, 1, 1],
padding="VALID",
name="conv")
# Apply nonlinearity
h = tf.nn.relu(tf.nn.bias_add(conv, b), name="relu")
# Max-pooling over the outputs
pooled = tf.nn.max_pool(
h,
ksize=[1, sequence_length - filter_size + 1, 1, 1],
strides=[1, 1, 1, 1],
padding='VALID',
name="pool")
pooled_outputs.append(pooled)
# Combine all the pooled features
num_filters_total = num_filters * len(filter_sizes)
self.h_pool = tf.concat(3, pooled_outputs)
self.h_pool_flat = tf.reshape(self.h_pool, [-1, num_filters_total])

Di sini, W adalah filter matrik dan h adalah hasil dari pengaplikasian dari nonlinearity menuju convolutional output. Setiap filter akan melakukan slides over the whole embedding, namun berapa kata yang ter-cover akan bervariasi. Padding “VALID” mempunyai arti bahwa kita melakukan slide pada filter di atas kalimat tanpa melakukan padding the edges, selanjutnya akan melakukan convolution yang sifatnya sempit yang memberikan bentuk output [1, sequence_length — filter_size + 1, 1, 1]. Melakukan max-pooling di atas output dari spesifik ukuran filter dan meninggalkan sebuah bentuk tensor [batch_size, 1, 1, num_filters]. Ini merupakan hal yang esensial sebagai sebuah fitur vektor, dimana dimensi terakhir cocok dengan fitur yang terakhir. Setelah kita telah mempunyai semua gabungan bentuk output tensor [batch_size, num_filters_total], kita menggunakan -1 di tf.reshape yang akan berbicara kepada TensorFlow untuk meratakan dimensi yang ada jika memungkinkan.

Luangkan waktu dan coba untuk pahami bentuk output untuk setiap operasi tersebut. Anda juga dapat melihat kembali artikel tentang Memahami Convolutional Neural Networks untuk NLP. Visualisasi operasi pada TensorBoard berikut mungkin akan menolong (untuk spesifik filter dengan ukuran 3, 4 dan 5 di sini):

Dropout Layer

Dropout besar kemungkinan merupakan metode popular untuk membuat convolutional neural networks teratur. Ide dibalik dropout sederhana. Sebuah layer dropout akan melakukan stochastic untuk menonaktifkan pecahan pada neuoran-nya. Ini untuk menghindarkan neuron dari co-adapting dan memaksa para neuron tersebut untuk mengaktifkan dengan mendefinisikan berdasarkan input dropout_keep_prob untuk network kita. Kita akan melakukan untuk sebuah set dengan 0,5 selama training, dan 1 (menonaktifkan dropout) selama evaluasi.

# Add dropout
with tf.name_scope("dropout"):
    self.h_drop = tf.nn.dropout(self.h_pool_flat, self.dropout_keep_prob)

Scores dan Predictions

Menggunakan fitur vektor dari max-pooling (tanpa mengaplikasikan dropout) kita dapat menghasilkan prediksi berdasarkan matrix multiplication dan menghasilkan kelas dengan skor paling tinggi. Kita juga dapat mengaplikasikan fungsi softmax untuk mengubah skor mentah kepada probabilitas normal, akan tetap itu tidak akan mengubah prediksi final.

with tf.name_scope("output"):
    W = tf.Variable(tf.truncated_normal([num_filters_total, num_classes], stddev=0.1), name="W")
    b = tf.Variable(tf.constant(0.1, shape=[num_classes]), name="b")
    self.scores = tf.nn.xw_plus_b(self.h_drop, W, b, name="scores")
    self.predictions = tf.argmax(self.scores, 1, name="predictions")

Di sini, tf.nn.xw_plus_b merupakan wrapper yang bagus untuk menampikan W x + b matrik multiplication.

Loss dan Accuracy

Menggunakan skor yang kita sendiri dapat mendefinisikan loss function. Loss merupakan suatu ukuran dari sebuah error yang dibuat oleh network, dan tujuannya adalah untuk meminimalisirnya. Standar fungsi loss untuk mengkategorisasikan masalah tersebut adalah cross-entropy loss.

# Calculate mean cross-entropy loss
with tf.name_scope("loss"):
    losses = tf.nn.softmax_cross_entropy_with_logits(self.scores, self.input_y)
    self.loss = tf.reduce_mean(losses)

Di sini, tf.nn.softmax_cross_entropy_with_logits merupakan fungsi yang memudahkan untuk melakukan kalkulasi cross-entropy loss untuk setiap kelas, memberikan skor dan input label yang benar. Kita kemudian akan mendapatkan rata-rata dari losses. Kita dapat juga mengunakan penjumlahan, namun itu akan membuatnya lebih sulit untuk membandingkan loss across ukuran batch berbeda dan data train/dev.

Kita juga mendefinisikan sebuah ekspresi untuk akurasi, yang mana berguna secara kuantitas untuk menjaga track selama training dan testing.

# Calculate Accuracy
with tf.name_scope("accuracy"):
    correct_predictions = tf.equal(self.predictions, tf.argmax(self.input_y, 1))
    self.accuracy = tf.reduce_mean(tf.cast(correct_predictions, "float"), name="accuracy")

Visualizing The Network

Di sini, kita telah selesai mendefinisikan network. Kode keseluruhan dari tersedia di sini. Untuk mendapatkan gambaran besarnya kita dapat melakukan visualisasi network pada TensorBoard:

Prodesur Training

Sebelum kita mendefinisikan prosedur training untuk network kita perlu memahami beberapa dasar tentang bagaimana TensorFlow menggunakan Sessions dan Graphs. Jika Anda sudah familiar dengan konsep tersebut bagian ini bisa dilewati.

Di TensorFlow, sebuah Session merupakan environtment Anda untuk mengeksekusi operasi graph dan mengandung state tentang Variables dan queues. Setiap sesi mengoperasikan pada sebuah single graph. Jika Anda tidak secara eksplisit menggunakan session ketika membuat variabel dan operasi Anda akan menggunakan sesi yang sedang berlaku yang dibuat oleh TensorFlow. Anda dapat mengubah default session dengan mengeksekusi perintah blok session.as_default() (lihat di bawah).

Sebuah Graph berisi operasi dan banyak tensors. Anda dapat menggunakan multiple graph pada program Anda, namun kebanyakan program hanya memerlukan single graph. Anda dapat menggunakan graph yang sama pada multiple sessions, tetapi tidak multiple graphs pada one session. TensorFlow selalu membuat default graph, namun Anda juga boleh membuat sebuah graph manual dan mengesetnya sebagai default yang baru, seperti yang kita lakukan di bawah. Yang secara eksplisit sessions dan graphs memastikan beberapa sumber dirilis dengan benar ketika Anda tidak membutuhkannya.

with tf.Graph().as_default():
    session_conf = tf.ConfigProto(
      allow_soft_placement=FLAGS.allow_soft_placement,
      log_device_placement=FLAGS.log_device_placement)
    sess = tf.Session(config=session_conf)
    with sess.as_default():
        # Code that operates on the default graph and session comes here...

Allow_soft_placement mengatur untuk memperbolehkan TensorFlow untuk kembali pada device dengan operasi tertentu yang terimplementasikan ketika device yang bersangkutan tidak terdeteksi. Sebagai contoh, jika kode kita ditempatkan operasinya pada sebuah GPU dan kita menjalankan kode pada sebuah mesin tanpa GPU, tidak menggunakan allow_soft_placement akan menghasilkan sebuah error. Jika log_device_placement telat diset, TensorFlow akan log on sesuai devices (CPU atau GPU) tempat operasi dijalankan. Ini berguna selama melakukan debugging. FLAGS merupakan argumen perintah untuk program kita.

Instantiating The CNN dan Minimizing The Loss

Ketika kita memberi contoh model TextCNN semua variabel dan operasi terdefinisikan akan ditempatkan pada default graph dan session telah kita buat di atas.

cnn = TextCNN(
sequence_length=x_train.shape[1],
num_classes=2,
vocab_size=len(vocabulary),
embedding_size=FLAGS.embedding_dim,
filter_sizes=map(int, FLAGS.filter_sizes.split(",")),
num_filters=FLAGS.num_filters)

Selanjutnya, kita definisikan bagaimana melakukan optimasisasi network loss function. Tensorflow mempunya beberapa built-in optimizers. Kita dapat menggunakan Adam optimizer.

global_step = tf.Variable(0, name="global_step", trainable=False)
optimizer = tf.train.AdamOptimizer(1e-4)
grads_and_vars = optimizer.compute_gradients(cnn.loss)
train_op = optimizer.apply_gradients(grads_and_vars, global_step=global_step)

Di sini, train_op merupakan operasi yang baru dibuat yang mana kita dapat menjalankan untuk menampilkan gradient yang baru pada parameter kita. Setiap eksekusi dari train_op adalah tahap training. TensorFlow otomatis memperhitungkan variabel mana yang “mudah ditraining” dan dihitung gradien-nya. Dengan mendefinisikan sebuah variabel global_step dan menggunakannya untuk mengoptimalisasi dan memperbolehkan TensofFlow meng-handle perhitungan dari langkah training. Tahapan global akan secara otomatis bertambah setiap Anda mengeksekusi train_op.

Summaries

TensorFlow mempunyai sebuah konsep untuk melakukan ringkasan (summaries), yang mana memperbolehkan Anda untuk menjaga track dan memvisualisasikan berbagai kuantitas selama training dan evaluasi. Sebagai contoh, Anda mungkin ingin untuk tetap menjaga track agar bagaimana loss dan akurasi berkembang dari waktu ke waktu. Anda juga dapat menjaga track agar lebih kompleks secara kuantitas, seperti histogram dari layer aktivasi. Summaries merupakan sebuah serial objek, dan mereka tertulis pada sebuah disk menggunakan sebuah SummaryWriter.

# Output directory for models and summaries
timestamp = str(int(time.time()))
out_dir = os.path.abspath(os.path.join(os.path.curdir, "runs", timestamp))
print("Writing to {}\n".format(out_dir))
 
# Summaries for loss and accuracy
loss_summary = tf.scalar_summary("loss", cnn.loss)
acc_summary = tf.scalar_summary("accuracy", cnn.accuracy)
 
# Train Summaries
train_summary_op = tf.merge_summary([loss_summary, acc_summary])
train_summary_dir = os.path.join(out_dir, "summaries", "train")
train_summary_writer = tf.train.SummaryWriter(train_summary_dir, sess.graph_def)
 
# Dev summaries
dev_summary_op = tf.merge_summary([loss_summary, acc_summary])
dev_summary_dir = os.path.join(out_dir, "summaries", "dev")
dev_summary_writer = tf.train.SummaryWriter(dev_summary_dir, sess.graph_def)

Di sini, kita secara terpisah melacak summaries untuk training dan evaluasi. Pada kasus ini merupakan jumlah yang sama, tetapi Anda boleh mempunyai kuantitas yang ingin Anda track hanya selama training (seperti parameter mengupdate nilai). tf.merge_summary merupakan sebuah fungsi yang memudahkan yang menggabungkan operasi multiple summary dalam sebuah single operasi yang kita dapat eksekusi.

Checkpointing

Fitur yang lain dari TensorFlow jika Anda secara khusus ingi menggunakan checkpointing — menyimpan parameter dari model Anda untuk mengembalikannya lain waktu. Checkpoints dapat digunakan untuk melanjutkan training pada waktu kemudian, atau ketika memilih parameter setting yang terbaik guna digunakan berhenti lebih awal. Checkpoints dibuat menggunakan sebuah objek Saver.

# Checkpointing
checkpoint_dir = os.path.abspath(os.path.join(out_dir, "checkpoints"))
checkpoint_prefix = os.path.join(checkpoint_dir, "model")
# Tensorflow assumes this directory already exists so we need to create it
if not os.path.exists(checkpoint_dir):
    os.makedirs(checkpoint_dir)
saver = tf.train.Saver(tf.all_variables())

Initializing The Variables

Sebelum kita dapat melakukan train model kita juga memerlukan initialize variable pada graph.

sess.run(tf.initialize_all_variables())

Fungsi initialize_all_variables merupakan fungsi yang memudahkan untuk menjalankan semua initializers yang telah definisikan untuk variabel kita. Anda dapat juga memanggil initializer dari variabel secara manual. Ini berguna jika Anda ingin melakukan initialize embeddings dengan nilai pre-trained sebagai contoh.

Defining A Single Training Step

Mari kita mendefinisikan sebuah fungsi untuk tahapan single training, mengevaluasi model pada batch of data dan memperbarui parameter model.

def train_step(x_batch, y_batch):
    """
    A single training step
    """
    feed_dict = {
      cnn.input_x: x_batch,
      cnn.input_y: y_batch,
      cnn.dropout_keep_prob: FLAGS.dropout_keep_prob
    }
    _, step, summaries, loss, accuracy = sess.run(
        [train_op, global_step, train_summary_op, cnn.loss, cnn.accuracy],
        feed_dict)
    time_str = datetime.datetime.now().isoformat()
    print("{}: step {}, loss {:g}, acc {:g}".format(time_str, step, loss, accuracy))
    train_summary_writer.add_summary(summaries, step)

feed_dict berisi data untuk placeholder nodes yang kita pass pada network. Anda mesti mengisi nilai untuk semua placeholders nodes, atau TensorFlow yang memunculkan error. Cara lain untuk berkerja dengan input data dapat menggunakan queues, namun itu di luar tema dari artikel ini.

Selanjutnya, kita akan mengeksekusi train_op menggunakan session.run, yang mana mengembalikan nilai untuk semua operasi yang kita minta untuk mengevaluasi. Catatan, train_op tidak mengembalikan apa-apa, itu hanya memperbarui parameter dari network. Dan akhirnya, kita mencetak the loss dan akurasi sejumlah training saat ini dan menyimpan summaries pada disk. Catatan bahwa the loss dan akurasi untuk sejumlah training bisa saja secara signifikan berbeda di beberapa jumlah jika batch size sifatnya kecil. Dan karena kita menggunakan dropout, matrik training bisa memulai menjadi lebih buruh daripada matrik evaluasi Anda.

Kita menulis sebuah fungsi yang sama untuk mengevaluasi the loss dan akurasi pada arbitrary dataset, seperti validation set atau seluruh training set. Secara esensial fungsi ini sama dengan yang di atas, akan tetapi tanpa operasi training. Ini juga menonaktifkan dropout.

def dev_step(x_batch, y_batch, writer=None):
    """
    Evaluates model on a dev set
    """
    feed_dict = {
      cnn.input_x: x_batch,
      cnn.input_y: y_batch,
      cnn.dropout_keep_prob: 1.0
    }
    step, summaries, loss, accuracy = sess.run(
        [global_step, dev_summary_op, cnn.loss, cnn.accuracy],
        feed_dict)
    time_str = datetime.datetime.now().isoformat()
    print("{}: step {}, loss {:g}, acc {:g}".format(time_str, step, loss, accuracy))
    if writer:
        writer.add_summary(summaries, step)

Training Loop

Pada akhirnya, kita siap untuk menulis training loop. Kita akan melakukan iterasi di atas sekumpulan data kita, memanggil fungsi train_step pada setiap kumpulan, dan sekali-kali mengevaluasi dan melakukan checkpoint pada model:

# Generate batches
batches = data_helpers.batch_iter(
    zip(x_train, y_train), FLAGS.batch_size, FLAGS.num_epochs)
# Training loop. For each batch...
for batch in batches:
    x_batch, y_batch = zip(*batch)
    train_step(x_batch, y_batch)
    current_step = tf.train.global_step(sess, global_step)
    if current_step % FLAGS.evaluate_every == 0:
        print("\nEvaluation:")
        dev_step(x_dev, y_dev, writer=dev_summary_writer)
        print("")
    if current_step % FLAGS.checkpoint_every == 0:
        path = saver.save(sess, checkpoint_prefix, global_step=current_step)
        print("Saved model checkpoint to {}\n".format(path))

Di sini batch_iter merupakan fungsi helper yang menulis pada sekumpulan data, dan tf.train.global_step merupakan fungsi yang membantuk nilai kembali dari global_step. Kode lengkap untuk training tersedia di sini.

Memvisualisasikan Hasil Menggunakan Tensorboard

Script training menuliskan summaries untuk output directory, dan menunjuk TensorBoard bahwa direktori tersebut dapat kita visualisasikan graph-nya dan summaries yang kita buat.

tensorboard --logdir /PATH_TO_CODE/runs/1449760558/summaries/

Menjalankan prosedur training dengan parameter default (128-dimensional embeddings, ukuran filter dari 3, 4 dan 5, dropout dari 0,5 dan 128 filter setiap ukuran filter) hasil pada loss berikut ini dan akurasi plot (biru merupakan training data, merah merupakan 10% dev data).

Ada beberapa hal yang mesti diperhatikan:

• Training matrik kita tidak berjalan mulus karena kita menggunakan sekumpulan data kecil. Jika kita menggunakan sekumpulan data yang lebih besar (atau mengevaluasi pada seluruh training set) kita akan mendapat garis biru yang lebih mulus.
• Karena akurasi dev secara signifikan di bawah akurasi training nampaknya seperti network is overfitting the training data, ini menunjukkan bahwa kita memerlukan lebih banyak (MR dataset sangat kecil), mempunyai regulasi yang lebih kuat, atau mempunyai parameter model yang lebih sedikit. Sebagai contoh, kita akan melakukan eksperimen dengan menambahkan dengan menambahkan additional L2 penalties untuk bobot pada layer terakhir dan memberikan efek bump up the accuracy to 76%, mendekati sesuai yang tertulis pada paper aslinya.
• Loss training dan akurasi menjadi starts out di bawah metrik dev karena menerapkan dropout.

Anda dapat bermain-main dengan kode yang ada dan mencoba menjalankan model dengan variasi konfigurasi parameter. Kode dan instruksi tersedia di Github.

*Naskah asli bisa diakses melalui tautan berikut.