💃🏽 🥕 👰 Menerapkan model seq2seq di Tensorflow 🍳 🔒 🖋️

Pembuatan data menggunakan jaringan saraf berulang menjadi metode yang semakin populer dan digunakan di banyak bidang ilmu komputer. Sejak awal kelahiran konsep seq2seq pada tahun 2014, hanya lima tahun telah berlalu, tetapi dunia telah melihat banyak aplikasi, mulai dengan model klasik terjemahan dan pengenalan suara, dan berakhir dengan generasi deskripsi objek dalam foto.

Di sisi lain, seiring waktu, perpustakaan Tensorflow, dirilis oleh Google khusus untuk pengembangan jaringan saraf, mendapatkan popularitas. Secara alami, pengembang Google tidak dapat mengabaikan paradigma populer seperti seq2seq, sehingga perpustakaan Tensorflow menyediakan kelas untuk pengembangan dalam paradigma ini. Artikel ini menjelaskan sistem kelas ini.

Jaringan Berulang

Saat ini, jaringan berulang adalah salah satu formalisme paling terkenal dan praktis untuk membangun jaringan saraf yang dalam. Jaringan rekursif dirancang untuk memproses data serial, oleh karena itu, tidak seperti sel normal (neuron), yang menerima data sebagai input dan output hasil perhitungan, sel rekursif berisi dua input dan dua output.

Salah satu input mewakili data elemen saat ini dari urutan, dan input kedua disebut keadaan dan ditransmisikan sebagai hasil perhitungan sel pada elemen sebelumnya dari urutan.

Gambar menunjukkan sel A, yang datanya elemen urutan adalah input $x_t$ serta kondisi yang tidak ditunjukkan di sini $s_ {t-1}$ . Pada output, sel A memberikan status $s_t$ dan hasil perhitungannya $h_t$ .

Dalam praktiknya, urutan data biasanya dibagi menjadi beberapa bagian dengan panjang tetap tertentu dan diteruskan ke perhitungan dengan seluruh himpunan bagian (kumpulan). Dengan kata lain, contoh adalah contoh untuk belajar. Input, output, dan keadaan sel dari jaringan rekursif adalah urutan bilangan real. Untuk perhitungan input $x_1$ perlu untuk menggunakan negara yang bukan hasil perhitungan pada urutan data yang diberikan. Keadaan demikian disebut keadaan awal. Jika urutannya cukup panjang, maka masuk akal untuk mempertahankan konteks perhitungan pada setiap urutan. Dalam hal ini, dimungkinkan untuk mentransmisikan keadaan yang dihitung terakhir dalam urutan sebelumnya sebagai keadaan awal. Jika urutannya tidak terlalu panjang atau urutannya adalah segmen pertama, maka Anda dapat menginisialisasi keadaan awal dengan nol.

Saat ini, untuk pelatihan jaringan saraf hampir di mana-mana algoritma back propagation of error digunakan . Hasil perhitungan pada set contoh yang dikirimkan (dalam kasus kami, set berikutnya) diperiksa terhadap hasil yang diharapkan (mark up data). Perbedaan antara nilai aktual dan yang diharapkan disebut kesalahan dan kesalahan ini disebarkan ke bobot jaringan di arah yang berlawanan. Dengan demikian, jaringan beradaptasi dengan data yang diberi label dan, sebagai suatu peraturan, hasil dari adaptasi ini bekerja dengan baik untuk data yang tidak dipenuhi oleh jaringan dalam contoh pelatihan awal (hipotesis generalisasi).

Dalam kasus jaringan rekursif, kami memiliki beberapa opsi yang keluarannya dianggap sebagai kesalahan. Kami akan jelaskan di sini dua yang utama:

Anda dapat mempertimbangkan kesalahan dengan membandingkan output sel terakhir dari hasil dengan output yang diharapkan. Ini berfungsi dengan baik untuk tugas klasifikasi. Sebagai contoh, kita perlu menentukan pewarnaan emosional tweet. Untuk melakukan ini, kami memilih tweet dan menandainya menjadi tiga kategori: negatif, positif dan netral. Output sel akan menjadi tiga angka - berat kategori. Tweet juga akan ditandai dengan tiga angka - probabilitas tweet yang termasuk dalam kategori yang sesuai. Setelah menghitung kesalahan pada subset data, Anda dapat menyebarkannya melalui output atau menyatakan sesuka Anda.
Anda dapat membaca kesalahan segera di output perhitungan sel untuk setiap elemen selanjutnya. Ini sangat cocok untuk tugas memprediksi elemen urutan berikutnya dari yang sebelumnya. Pendekatan ini dapat digunakan, misalnya, dalam masalah menentukan anomali dalam serangkaian waktu data atau dalam tugas memprediksi karakter berikutnya dalam teks, untuk kemudian menghasilkannya. Propagasi kesalahan juga dimungkinkan melalui status atau keluaran.

Tidak seperti jaringan saraf yang terhubung penuh secara teratur, jaringan rekursif dalam arti bahwa kesalahan menyebar tidak hanya turun dari output jaringan ke bobotnya, tetapi juga ke kiri, melalui koneksi antar negara. Kedalaman jaringan ditentukan oleh panjang urutan. Untuk menyebarkan kesalahan melalui keadaan jaringan rekursif, ada algoritma khusus. Fiturnya adalah bahwa gradien dari bobot saling berlipat ganda, ketika kesalahan menyebar dari kanan ke kiri. Jika kesalahan awal lebih besar dari satu, maka akibatnya, kesalahan bisa menjadi sangat besar. Sebaliknya, jika kesalahan awal kurang dari satu, maka di suatu tempat di awal urutan kesalahan mungkin memudar. Situasi ini dalam teori jaringan saraf disebut korsel kesalahan standar. Untuk menghindari situasi seperti itu selama pelatihan, sel-sel khusus diciptakan yang tidak memiliki kelemahan seperti itu. Sel seperti pertama adalah LSTM , sekarang ada berbagai alternatif, yang GRU paling populer.

Pengantar yang baik untuk jaringan pengulangan dapat ditemukan di artikel ini . Sumber terkenal lainnya adalah artikel dari blog Andrey Karpaty.

Perpustakaan Tensorflow memiliki banyak kelas dan fungsi untuk mengimplementasikan jaringan rekursif. Berikut ini adalah contoh membuat jaringan rekursif dinamis berdasarkan sel dari tipe GRU:

cell = tf.contrib.rnn.GRUCell(dimension) outputs, state = tf.nn.dynamic_rnn(cell, input, sequence_length=input_length, dtype=tf.float32)

Dalam contoh ini, sel GRU dibuat, yang kemudian digunakan untuk membuat jaringan rekursif dinamis. Tensor data input dan panjang aktual dari baris-baris selanjutnya dikirimkan ke jaringan. Input data selalu ditentukan oleh vektor bilangan real. Untuk nilai tunggal, misalnya, kode simbol atau kata, yang disebut embedding - memetakan kode ini ke beberapa urutan angka. Fungsi membuat jaringan rekursif dinamis mengembalikan sepasang nilai: daftar output jaringan untuk semua nilai urutan dan keadaan yang dihitung terakhir. Sebagai input, fungsi mengambil sel, menginput data, dan tensor panjang berikutnya.

Jaringan rekursif dinamis berbeda dari yang statis di mana ia tidak membuat jaringan sel jaringan untuk selanjutnya di muka (pada tahap menentukan grafik perhitungan), tetapi meluncurkan sel pada input secara dinamis selama perhitungan grafik pada data input. Oleh karena itu, fungsi ini perlu mengetahui panjang urutan input data agar berhenti pada waktu yang tepat.

Menghasilkan model berdasarkan jaringan perulangan

Menghasilkan jaringan perulangan

Sebelumnya, kami mempertimbangkan dua metode untuk menghitung kesalahan jaringan rekursif: pada output terakhir atau pada semua output untuk urutan tertentu. Di sini kami mempertimbangkan masalah menghasilkan urutan. Pelatihan jaringan generator didasarkan pada metode kedua di atas.

Secara lebih rinci, kami mencoba untuk melatih jaringan rekursif untuk memprediksi elemen berurutan berikutnya. Seperti disebutkan di atas, output sel dalam jaringan rekursif hanyalah urutan angka. Vektor ini sangat tidak nyaman untuk dipelajari, oleh karena itu, mereka memperkenalkan level lain, yang menerima vektor ini pada input, dan pada output memberikan bobot prediksi. Level ini disebut level proyeksi dan memungkinkan Anda untuk membandingkan output sel pada elemen tertentu dari urutan dengan output yang diharapkan dalam data berlabel.

Untuk menggambarkan, pertimbangkan tugas menghasilkan teks yang direpresentasikan sebagai urutan karakter. Panjang vektor output dari level proyeksi sama dengan ukuran alfabet teks sumber. Ukuran alfabet biasanya tidak melebihi 150 karakter, jika Anda menghitung karakter bahasa Rusia dan Inggris, serta tanda baca. Output dari level proyeksi adalah vektor dengan panjang alfabet, di mana setiap simbol sesuai dengan posisi tertentu dalam vektor ini - indeks simbol ini. Data berlabel juga merupakan vektor yang terdiri dari nol, di mana seseorang berdiri pada posisi karakter mengikuti urutan.

Untuk pelatihan, kami menggunakan dua urutan data:

Urutan karakter dalam teks sumber, di awal yang ditambahkan karakter khusus yang bukan bagian dari teks sumber. Biasanya disebut sebagai go .
Urutan karakter teks sumber apa adanya, tanpa tambahan.

Contoh untuk teks "ibu mencuci bingkai":

 ['<go>', '', '', ', '', ' ', '', '', '', '', ' ', '', '', '', ''] ['', '', ', '', ' ', '', '', '', '', ' ', '', '', '', '']

Untuk pelatihan, minibatch biasanya dibentuk, yang terdiri dari sejumlah kecil contoh. Dalam kasus kami, ini adalah string yang panjangnya bisa berbeda. Kode yang dijelaskan di bawah ini menggunakan metode berikut untuk menyelesaikan masalah dengan panjang yang berbeda. Dari banyak garis dalam paket mini ini, panjang maksimum dihitung. Semua baris lainnya diisi dengan karakter khusus (padding) sehingga semua contoh dalam minipacket memiliki panjang yang sama. Dalam contoh kode di bawah ini, string pad digunakan sebagai karakter seperti itu. Juga, untuk generasi yang lebih baik, di akhir contoh, tambahkan simbol akhir kalimat - eos . Dengan demikian, pada kenyataannya, data dari contoh akan terlihat sedikit berbeda:

 ['<go>', '', '', ', '', ' ', '', '', '', '', ' ', '', '', '', '', '<eos>', '<pad>', '<pad>', '<pad>'] ['', '', ', '', ' ', '', '', '', '', ' ', '', '', '', '', '<eos>', '<pad>', '<pad>', '<pad>', '<pad>']

Urutan pertama diumpankan ke input jaringan, dan urutan kedua digunakan sebagai data yang ditandai. Pelatihan prediksi didasarkan pada pengalihan urutan asli satu karakter ke kiri.

Pelatihan dan pemijahan

Pelatihan

Algoritma pembelajarannya cukup sederhana. Untuk setiap elemen dari urutan input, kami menghitung vektor output dari level proyeksi dan membandingkannya dengan yang ditandai. Satu-satunya pertanyaan adalah bagaimana cara menghitung kesalahan. Anda bisa menggunakan root mean square error, tetapi untuk menghitung kesalahan dalam situasi ini, lebih baik menggunakan cross entropy . Pustaka Tensorflow menyediakan beberapa fungsi untuk perhitungannya, meskipun tidak ada yang menghentikan implementasi rumus perhitungan langsung dalam kode.

Untuk kejelasan, kami memperkenalkan beberapa notasi. Dengan symbol_id kita akan menunjukkan pengenal simbol (nomor seri dalam alfabet). Simbol istilah di sini agak sewenang-wenang dan hanya berarti elemen alfabet. Alfabet mungkin tidak mengandung simbol, tetapi kata-kata atau bahkan beberapa set atribut yang lebih kompleks. Istilah symbol_embedding akan digunakan untuk menunjukkan vektor angka yang sesuai dengan elemen alfabet tertentu. Biasanya, set angka tersebut disimpan dalam tabel ukuran yang cocok dengan ukuran alfabet.

Tensorflow menyediakan fitur yang memungkinkan Anda untuk mengakses tabel penyematan dan mengganti indeks karakter dengan vektor penyematan mereka. Pertama, kita mendefinisikan variabel untuk menyimpan tabel:

 embedding_table = tf.Variable(tf.random_uniform([alphabet_size, embedding_size]))

Setelah itu, Anda bisa mengonversi tensor input menjadi embedded tensor:

 input_embeddings = tf.nn.embedding_lookup(embedding_table, input_ids)

Hasil pemanggilan fungsi adalah tensor dari dimensi yang sama yang ditransfer ke input, tetapi sebagai hasilnya, semua indeks karakter diganti dengan urutan embedding yang sesuai.

Muncul

Untuk menghitung, sel jaringan rekursif membutuhkan status dan karakter saat ini. Hasil perhitungannya adalah jalan keluar dan status baru. Jika kita menerapkan tingkat proyeksi ke output, kita bisa mendapatkan vektor bobot di mana bobot pada posisi yang sesuai dapat dipertimbangkan (sangat kondisional) karena probabilitas simbol ini muncul di posisi berikutnya dalam urutan.

Berbagai strategi dapat digunakan untuk memilih simbol berikutnya berdasarkan vektor bobot yang dihasilkan oleh tingkat proyeksi:

Strategi pencarian serakah. Setiap kali kita memilih simbol dengan bobot tertinggi, mis. kemungkinan besar dalam situasi ini, tetapi belum tentu yang paling tepat dalam konteks seluruh urutan.
Strategi untuk memilih urutan terbaik (pencarian balok). Kami tidak memilih simbol sekaligus, tetapi ingat beberapa varian simbol yang paling mungkin. Setelah semua opsi tersebut dihitung untuk semua elemen dari urutan yang dihasilkan, kami memilih urutan karakter yang paling mungkin, dengan mempertimbangkan konteks seluruh urutan. Biasanya, ini diwujudkan dengan menggunakan matriks yang lebarnya sama dengan panjang urutan, dan tinggi dengan jumlah varian menghasilkan karakter (lebar pencarian balok). Setelah generasi varian urutan selesai, salah satu varian dari algoritma Viterbi digunakan untuk memilih urutan yang paling mungkin.

Tensorflow perpustakaan sistem tipe seq2seq

Mengingat hal di atas, jelas bahwa implementasi model generatif berdasarkan jaringan pengulangan adalah tugas yang agak sulit untuk pengkodean. Oleh karena itu, tentu saja, sistem kelas diusulkan untuk memfasilitasi solusi dari masalah ini. Salah satu sistem ini disebut seq2seq, lalu kami menggambarkan fungsionalitas dari jenis utamanya.

Tapi, pertama-tama, beberapa kata tentang nama perpustakaan. Nama seq2seq adalah singkatan untuk urutan ke urutan (dari urutan ke urutan). Gagasan asli untuk menghasilkan urutan diusulkan untuk menerapkan sistem terjemahan. Urutan input kata diumpankan ke input jaringan rekursif, yang disebut encoder dalam sistem ini. Output dari jaringan rekursif ini adalah keadaan perhitungan sel pada karakter terakhir dari urutan. Keadaan ini disajikan sebagai keadaan awal dari jaringan rekursif kedua, decoder, yang dilatih untuk menghasilkan kata berikutnya. Kata-kata itu digunakan sebagai simbol di kedua jaringan. Kesalahan pada dekorator disebarkan ke encoder melalui kondisi yang ditransmisikan. Vektor keadaan itu sendiri dalam terminologi ini disebut vektor pemikiran. Presentasi antara digunakan dalam model terjemahan tradisional dan, sebagai aturan, adalah grafik yang mewakili struktur teks input untuk terjemahan. Sistem terjemahan menghasilkan teks keluaran berdasarkan pada struktur perantara ini.

Sebenarnya, implementasi seq2seq di Tensorflow adalah bagian dari decoder, tanpa mempengaruhi encoder. Oleh karena itu, akan tepat untuk memanggil perpustakaan 2seq, tetapi kekuatan tradisi dan kelambanan berpikir di sini jelas menang atas akal sehat.

Dua metatypes utama di perpustakaan seq2seq adalah:

Kelas pembantu .
Dekoder Kelas.

Pengembang perpustakaan mengidentifikasi tipe-tipe ini berdasarkan pertimbangan berikut. Mari kita perhatikan proses pembelajaran dan proses generasi, yang kami jelaskan di atas, dari sudut yang sedikit berbeda.

Untuk pelatihan Anda membutuhkan:

Untuk setiap karakter, berikan perhitungan kondisi saat ini dan penyematan karakter saat ini.
Ingat status output dan proyeksi yang dihitung untuk output.
Dapatkan karakter berikutnya dalam urutan dan lanjutkan ke langkah 1.

Setelah itu, Anda dapat mulai menghitung kesalahan dengan membandingkan hasil perhitungan dengan karakter urutan berikut.

Untuk menghasilkan itu perlu:

Untuk setiap karakter, berikan perhitungan kondisi saat ini dan penyematan karakter saat ini.
Ingat status output dan proyeksi yang dihitung untuk output.
Hitung karakter berikutnya sebagai maksimum dari indeks level proyeksi dan lanjutkan ke langkah 1.

Seperti yang dapat dilihat dari deskripsi, algoritma sangat mirip. Oleh karena itu, pengembang perpustakaan memutuskan untuk merangkum prosedur untuk mendapatkan karakter berikutnya di kelas Helper. Untuk pelatihan, ini hanya membaca karakter berikutnya dari urutan, dan untuk menghasilkannya, memilih karakter dengan bobot maksimum (tentu saja, untuk pencarian serakah).

Dengan demikian, kelas dasar Helper mengimplementasikan metode next_inputs untuk mendapatkan karakter berikutnya dari kondisi saat ini dan negara, serta metode sampel untuk mendapatkan indeks karakter dari level proyeksi. Untuk implementasi pelatihan, kelas TrainingHelper disediakan, dan untuk implementasi generasi dengan metode pencarian serakah, kelas GreedyEmbeddingHelper disediakan . Sayangnya, model pencarian balok tidak cocok dengan sistem jenis ini, oleh karena itu, kelas khusus BeamSearchDecoder diimplementasikan di perpustakaan untuk ini. tidak menggunakan Helper.

Kelas Decoder menyediakan antarmuka untuk mengimplementasikan decoder. Bahkan, kelas menyediakan dua metode:

inisialisasi untuk menginisialisasi pada awal pekerjaan.
langkah untuk menerapkan langkah atau generasi pembelajaran. Isi langkah ini ditentukan oleh Helper yang sesuai.

Perpustakaan mengimplementasikan kelas BasicDecoder , yang dapat digunakan baik untuk pelatihan dan untuk berkembang biak dengan asisten TrainingHelper dan GreedyEmbeddingHelper. Ketiga kelas ini biasanya cukup untuk menerapkan model pembangkitan berdasarkan jaringan perulangan.

Akhirnya, fungsi dynamic_decode digunakan untuk mengatur bagian melalui input atau urutan yang dihasilkan.

Selanjutnya, kita akan mempertimbangkan contoh ilustratif, yang menunjukkan metode untuk membangun model pembangkit untuk berbagai jenis pustaka seq2seq.

Contoh ilustratif

Pertama-tama, harus dikatakan bahwa semua contoh diimplementasikan dalam Python 2.7. Daftar pustaka tambahan dapat ditemukan di file requirement.txt.

Sebagai contoh ilustratif, pertimbangkan bagian dari data untuk Tantangan Normalisasi Teks - kontes Bahasa Rusia yang diselenggarakan oleh Kaggle oleh Google pada tahun 2017. Tujuan dari kompetisi ini adalah untuk mengubah teks Rusia menjadi bentuk yang cocok untuk dibaca. Teks untuk kontes dipecah menjadi ekspresi yang diketik. Data pelatihan ditentukan dalam file CSV dari formulir berikut:

 "sentence_id","token_id","class","before","after" 0,0,"PLAIN","","" 0,1,"PLAIN","","" 0,2,"PLAIN","","" 0,3,"DATE","1862 ","    " 0,4,"PUNCT",".","." 1,0,"PLAIN","","" 1,1,"PLAIN","","" 1,2,"PLAIN","","" 1,3,"PLAIN","","" 1,4,"PLAIN","","" 1,5,"PLAIN","","" 1,6,"PLAIN","","" 1,7,"PLAIN","","" 1,8,"PLAIN","","" 1,9,"PUNCT",".","." ...

Dalam contoh di atas, ekspresi tipe DATE menarik, di dalamnya, "1862" diterjemahkan menjadi "seribu delapan ratus enam puluh dua tahun." Untuk menggambarkan, kami menganggap data tipe DATE hanya sebagai pasangan bentuk (ekspresi sebelum, ekspresi setelah). Mulai file data:

 before,after 1862 ,     1811 ,    12  2013,      15  2013,      1905 ,    17  2014,      7  2010 ,      1 ,  1843 ,     30  2007 ,      1846 ,     1996 ,     9 ,  ...

Kami akan membangun model pembangkit menggunakan perpustakaan seq2seq, di mana encoder akan diimplementasikan pada level simbol (mis., Elemen alfabet adalah simbol), dan decoder akan menggunakan kata-kata sebagai alfabet. Kode contoh, seperti data, tersedia di repositori di Github .

Data pelatihan dibagi menjadi tiga himpunan bagian: train.csv, test.csv dan dev.csv, masing-masing untuk pelatihan, pengujian dan pelatihan ulang verifikasi. Data ada di direktori data. Tiga model diimplementasikan dalam repositori: seq2seq_greedy.py, seq2seq_attention.py dan seq2seq_beamsearch.py. Di sini kita melihat kode untuk model pencarian serakah dasar.

Semua model menggunakan kelas Estimator untuk mengimplementasikan. Menggunakan kelas ini memungkinkan Anda untuk menyederhanakan pengkodean tanpa terganggu oleh bagian-bagian non-model. Misalnya, tidak perlu menerapkan siklus transfer data untuk pelatihan, membuat sesi untuk bekerja dengan Tensorflow, berpikir tentang mentransfer data ke Tensorboard, dll. Estimator hanya membutuhkan dua fungsi untuk implementasinya: untuk transfer data dan untuk membangun model. Contoh-contoh juga menggunakan kelas Dataset untuk melewatkan data untuk diproses. Implementasi modern ini jauh lebih cepat daripada kamus tradisional untuk mentransfer data dari form feed_dict.

Pembuatan data

Pertimbangkan kode pembuatan data untuk pelatihan dan pembangkitan.

 def parse_fn(line_before, line_after): # Encode in Bytes for TF source = [c.encode('utf8') for c in line_before.decode('utf8').rstrip('\n')] t = [w.encode('utf8') for w in nltk.word_tokenize(line_after.decode('utf8').strip())] learn_target = t + ['<eos>'] + ['<pad>'] target = ['<go>'] + t + ['<eos>'] return (source, len(source)), (target, learn_target, len(target)) def generator_fn(data_file): with open(data_file, 'rb') as f: reader = csv.DictReader(f, delimiter=',', quotechar='"') for row in reader: yield parse_fn(row['before'], row['after']) def input_fn(data_file, params=None): params = params if params is not None else {} shapes = (([None], ()), ([None], [None], ())) types = ((tf.string, tf.int32), (tf.string, tf.string, tf.int32)) defaults = (('<pad>', 0), ('<pad>', '<pad>', 0)) dataset = tf.data.Dataset.from_generator(functools.partial(generator_fn, data_file), output_shapes=shapes, output_types=types) dataset = dataset.repeat(params['epochs']) return (dataset.padded_batch(params.get('batch_size', 50), shapes, defaults).prefetch(1))

Fungsi input_fn digunakan untuk membuat kumpulan data yang kemudian Estimator lewati untuk pelatihan dan pembangkitan. Tipe data diatur terlebih dahulu. Ini adalah sepasang bentuk ((urutan encoder, panjang), (urutan decoder, urutan decoder dengan awalan, panjang)). String "" digunakan sebagai awalan, setiap urutan enkoder diakhiri dengan kata "" khusus. Juga, karena fakta bahwa sekuens (baik input dan output) memiliki panjang yang tidak sama, simbol padding dengan nilai "" digunakan.

Kode persiapan data membaca file data, membagi string encoder menjadi karakter, dan string decoder menjadi kata-kata, menggunakan perpustakaan nltk untuk ini. Baris yang diproses dengan cara ini adalah contoh data pelatihan. Koleksi yang dihasilkan dibagi menjadi paket-mini, dan jumlah data dikloning sesuai dengan jumlah era pelatihan (setiap zaman adalah satu data pass).

Bekerja dengan kamus

Kamus disimpan sebagai daftar dalam file, satu baris untuk satu kata atau karakter. Untuk membuat kamus, gunakan skrip build_vocabs.py. Kamus yang dihasilkan terletak di direktori data sebagai file dari bentuk vocab. *. Txt.

Kode untuk membaca kamus:

 # Read vocabs and inputs dropout = params['dropout'] source, source_length = features training = (mode == tf.estimator.ModeKeys.TRAIN) vocab_source = tf.contrib.lookup.index_table_from_file(vocabulary_file=params['source_vocab_file'], num_oov_buckets=params['num_oov_buckets']) with open(params['source_vocab_file']) as f: num_sources = sum(1 for _ in f) + params['num_oov_buckets'] vocab_target = tf.contrib.lookup.index_table_from_file(vocabulary_file=params['target_vocab_file'], num_oov_buckets=params['num_oov_buckets']) with open(params['target_vocab_file']) as f: num_targets = sum(1 for _ in f) + params['num_oov_buckets']

Di sini, mungkin, fungsi index_table_from_file menarik, yang membaca elemen kamus dari file, dan parameternya num_oov_buckets adalah jumlah keranjang kata yang tidak lengkap. Secara default, angka ini sama dengan satu, yakni semua kata yang tidak ada dalam kamus memiliki indeks yang sama dengan ukuran kamus + 1. Kami memiliki tiga kata yang tidak dikenal: "", "" dan "", yang kami ingin memiliki indeks yang berbeda. Karena itu, atur parameter ini ke nomor tiga. Sayangnya, Anda harus membaca file input lagi untuk mendapatkan jumlah kata dalam kamus sebagai konstanta waktu untuk mengatur grafik model.

Kita masih perlu membuat tabel untuk mengimplementasikan embedding - _source_embedding, serta menerjemahkan string kata ke string pengidentifikasi:

 # source embeddings matrix _source_embedding = tf.Variable(tf.random_uniform([num_sources, params['embedding_size']])) source_ids = vocab_source.lookup(source) source_embedding = tf.nn.embedding_lookup(_source_embedding, source_ids)

Implementasi Encoder

Untuk pembuat enkode, kami akan menggunakan jaringan rekursif dua arah dengan beberapa level. , , .

 # add multilayer bidirectional RNN cell_fw = tf.contrib.rnn.MultiRNNCell([tf.contrib.rnn.GRUCell(params['dim']) for _ in range(params['layers'])]) cell_bw = tf.contrib.rnn.MultiRNNCell([tf.contrib.rnn.GRUCell(params['dim']) for _ in range(params['layers'])]) outputs, states = tf.nn.bidirectional_dynamic_rnn(cell_fw, cell_bw, source_embedding, sequence_length=source_length, dtype=tf.float32) # prepare output output = tf.concat(outputs, axis=-1) encoder_output = tf.layers.dense(output, params['dim']) # prepare state state_fw, state_bw = states cells = [] for fw, bw in zip(state_fw, state_bw): state = tf.concat([fw, bw], axis=-1) cells += [tf.layers.dense(state, params['dim'])] encoder_state = tuple(cells)

GRU, MultiRNNCell, , rnn.Cell. ,
sequence_length — , , .

, , , . , 128, 256. , , 128. .

. Karena , , bidirectional_dynamic_rnn, , . , . , .. . , , . , , .

, . .

  # decoder RNN cell decoder_cell = tf.contrib.rnn.MultiRNNCell([tf.contrib.rnn.GRUCell(params['dim']) for _ in range(params['layers'])]) decoder_initial_state = encoder_state # projection layer projection_layer = tf.layers.Dense(num_targets, use_bias=False) # embedding table for targets target_embedding = tf.Variable(tf.random_uniform([num_targets, params['embedding_size']]))

TrainingHelper + BasicDecoder.

  # target embeddings matrix target, learn_target, target_length = labels target_ids = vocab_target.lookup(target) target_learn_ids = vocab_target.lookup(learn_target) # train encoder _target_embedding = tf.nn.embedding_lookup(target_embedding, target_ids) train_helper = tf.contrib.seq2seq.TrainingHelper(_target_embedding, target_length) train_decoder = tf.contrib.seq2seq.BasicDecoder(decoder_cell, train_helper, decoder_initial_state, output_layer=projection_layer) train_outputs, _, _ = tf.contrib.seq2seq.dynamic_decode(train_decoder) train_output = train_outputs.rnn_output train_sample_id = train_outputs.sample_id

 # prediction decoder prediction_helper = tf.contrib.seq2seq.GreedyEmbeddingHelper( embedding=target_embedding, start_tokens=tf.fill([batch_size], tf.to_int32(vocab_target.lookup(tf.fill([], '<go>')))), end_token=tf.to_int32(vocab_target.lookup(tf.fill([], '<eos>')))) prediction_decoder = tf.contrib.seq2seq.BasicDecoder(decoder_cell, prediction_helper, decoder_initial_state, output_layer=projection_layer) prediction_output, _, _ = tf.contrib.seq2seq.dynamic_decode(prediction_decoder, maximum_iterations=params['max_iters']) # prepare prediction reverse_vocab_target = tf.contrib.lookup.index_to_string_table_from_file(params['target_vocab_file']) pred_strings = reverse_vocab_target.lookup(tf.to_int64(prediction_output.sample_id)) predictions = { 'ids': prediction_output.sample_id, 'text': pred_strings }

GreedyEmbeddingHelper "", "". . , , dynamic_decode . , , . , , .

, seq2seq.

 # loss masks = tf.sequence_mask(lengths=target_length, dtype=tf.float32) loss = tf.contrib.seq2seq.sequence_loss(logits=train_output, targets=target_learn_ids, weights=masks)

, , sequence_mask.

Adam , .

 optimizer = tf.train.AdamOptimizer(learning_rate=params.get('lr', .001)) grads, vs = zip(*optimizer.compute_gradients(loss)) grads, gnorm = tf.clip_by_global_norm(grads, params.get('clip', .5)) train_op = optimizer.apply_gradients(zip(grads, vs), global_step=tf.train.get_or_create_global_step())

. 0.9 . , , , . , .

 24  1944                 1  2003              1992 .           11  1927               1969            1  2016             1047          1863            17      22  2014

. — , — , — .

, — . . , ( ), . . , .

Kesimpulan

seq2seq. , , . , .

. Tensorflow , , . , , . , . , , padding , embedding ? , , . — . , , . , , , . , . , , , , .

Menerapkan model seq2seq di Tensorflow