Membina penjana teks menggunakan rantai Markov

Dalam artikel ini, kami akan memperkenalkan projek pembelajaran mesin yang popular - penjana teks Anda akan belajar cara membina penjana teks dan belajar cara melaksanakan rantaian Markov untuk mencapai model ramalan yang lebih pantas.

Pengenalan kepada Penjana Teks

Penjanaan teks popular merentas industri, terutamanya dalam mudah alih, apl dan sains data. Malah akhbar menggunakan penjanaan teks untuk membantu proses penulisan.

Dalam kehidupan seharian, kami didedahkan kepada beberapa teknologi penjanaan teks, cadangan carian, Karang Pintar dan bot sembang adalah semua contoh aplikasi

Artikel ini akan menggunakan rantaian Markov Penjana teks. Ini akan menjadi model berasaskan aksara yang mengambil aksara sebelumnya bagi rantai dan menjana huruf seterusnya dalam jujukan.

Dengan melatih program kami menggunakan perkataan contoh, penjana teks akan mempelajari corak susunan aksara biasa. Penjana teks kemudiannya akan menggunakan corak ini pada input, yang merupakan perkataan yang tidak lengkap, dan mengeluarkan aksara dengan kebarangkalian tertinggi untuk melengkapkan perkataan.

Penjanaan teks ialah satu cabang pemprosesan bahasa semula jadi yang meramal dan menjana aksara seterusnya berdasarkan corak bahasa yang diperhatikan sebelum ini.

Sebelum pembelajaran mesin, NLP melakukan penjanaan teks dengan mencipta jadual yang mengandungi semua perkataan dalam bahasa Inggeris dan memadankan rentetan yang diluluskan dengan perkataan sedia ada. Terdapat dua masalah dengan pendekatan ini.

• Mencari beribu-ribu perkataan akan menjadi sangat perlahan.
• Penjana hanya boleh melengkapkan perkataan yang pernah dilihatnya sebelum ini.

Kemunculan pembelajaran mesin dan pembelajaran mendalam telah membolehkan kami mengurangkan masa jalan secara drastik dan meningkatkan keluasan dalam NLP kerana penjana boleh melengkapkan perkataan yang tidak pernah ditemui sebelum ini. NLP boleh dilanjutkan untuk meramal perkataan, frasa atau ayat jika dikehendaki!

Untuk projek ini kami akan melakukannya secara eksklusif menggunakan rantai Markov. Proses Markov adalah asas kepada banyak projek pemprosesan bahasa semula jadi yang melibatkan bahasa bertulis dan simulasi sampel daripada pengedaran kompleks.

Proses Markov sangat berkuasa sehingga ia boleh digunakan untuk menjana teks yang kelihatan kelihatan nyata menggunakan hanya sampel dokumen.

Apakah rantai Markov?

Rantai Markov ialah proses stokastik yang memodelkan urutan peristiwa di mana kebarangkalian setiap peristiwa bergantung pada keadaan peristiwa sebelumnya . Model ini mempunyai set keadaan terhingga, dan kebarangkalian bersyarat untuk berpindah dari satu keadaan ke keadaan lain adalah tetap.

Kebarangkalian setiap peralihan hanya bergantung pada keadaan model sebelumnya, bukan keseluruhan sejarah peristiwa.

Sebagai contoh, katakan anda ingin membina model rantai Markov untuk meramal cuaca.

Dalam model ini kita mempunyai dua keadaan, cerah atau hujan. Jika kita mempunyai hari yang cerah hari ini, terdapat kebarangkalian yang lebih tinggi (70%) bahawa ia akan cerah esok. Begitu juga dengan hujan; jika sudah hujan, kemungkinan hujan akan terus turun.

Tetapi ada kemungkinan (30%) cuaca akan berubah keadaan, jadi kami memasukkannya dalam model rantai Markov kami juga.

Rantaian Markov ialah model yang sesuai untuk penjana teks kami kerana model kami akan meramalkan watak seterusnya hanya menggunakan aksara sebelumnya. Kelebihan menggunakan rantai Markov ialah ia tepat, memerlukan kurang memori (hanya 1 keadaan sebelumnya disimpan) dan pantas untuk dilaksanakan.

Pelaksanaan penjanaan teks

Di sini kami akan melengkapkan penjana teks dalam 6 langkah:

1. Jana jadual carian: Cipta jadual untuk merekod kekerapan perkataan
2. Tukar frekuensi kepada kebarangkalian: Tukar penemuan kami ke dalam bentuk yang boleh digunakan
3. Muatkan set data: Muatkan dan gunakan set latihan
4. Bina rantai Markov: Gunakan kebarangkalian untuk setiap perkataan dan penciptaan watak rantai
5. Sampel data: Buat fungsi untuk sampel pelbagai bahagian korpus
6. Jana teks: Uji model kami

1. Hasilkan jadual carian

Pertama, kami akan mencipta jadual untuk merekodkan kejadian setiap keadaan watak dalam korpus latihan. Simpan aksara 'K' dan aksara 'K+1' terakhir daripada korpus latihan dan simpannya dalam jadual carian.

Sebagai contoh, bayangkan korpus latihan kami mengandungi, "lelaki itu adalah, mereka, kemudian, si, itu". Maka bilangan kemunculan perkataan itu ialah:

• "the" — 3
• "then" — 1
• "they" — 1
• " lelaki” — 1

Berikut ialah keputusan dalam jadual carian:

Dalam contoh di atas, kami mengambil K = 3, yang bermaksud bahawa 3 aksara akan dipertimbangkan pada satu masa dan aksara seterusnya (K+1) akan digunakan sebagai aksara output . Anggap perkataan (X) sebagai aksara dalam jadual carian di atas dan aksara output (Y) sebagai ruang tunggal (" ") kerana tiada perkataan selepas yang pertama. Juga dikira ialah bilangan kali urutan ini muncul dalam set data, dalam kes ini 3 kali.

Ini menjana data untuk setiap perkataan dalam korpus, iaitu, semua kemungkinan pasangan X dan Y dijana.

Berikut ialah cara kami menjana jadual carian dalam kod:

 def generateTable(data,k=4):
 
 T = {}
for i in range(len(data)-k):
X = data[i:i+k]
Y = data[i+k]
#print("X %s and Y %s "%(X,Y))
if T.get(X) is None:
T[X] = {}
T[X][Y] = 1
else:
if T[X].get(Y) is None:
T[X][Y] = 1
else:
T[X][Y] += 1
return T
 T = generateTable("hello hello helli")
 print(T)
 
 #{'llo ': {'h': 2}, 'ello': {' ': 2}, 'o he': {'l': 2}, 'lo h': {'e': 2}, 'hell': {'i': 1, 'o': 2}, ' hel': {'l': 2}}

Penjelasan ringkas tentang kod:

Dalam baris 3, kamus dicipta yang akan menyimpan X dan nilai Y dan kekerapan yang sepadan. Baris 9 hingga 17 menyemak kemunculan X dan Y. Jika sudah ada pasangan X dan Y dalam kamus carian, cuma tambahkannya sebanyak 1.

2. Tukar kekerapan kepada kebarangkalian

Sebaik sahaja kita mempunyai jadual ini dan bilangan kejadian, kita boleh mendapatkan kebarangkalian bahawa Y berlaku selepas kejadian x. Formulanya ialah:

Sebagai contoh, jika X = the, Y = n, formula kita adalah seperti ini:

Apabila X =the Y = n Kekerapan: 2, jumlah kekerapan dalam jadual: 8, oleh itu: P = 2/8= 0.125= 12.5%

Berikut ialah cara kami menggunakan formula ini untuk menukar jadual carian kepada rantai Markov dengan kebarangkalian yang boleh digunakan:

 def convertFreqIntoProb(T):
for kx in T.keys():
s = float(sum(T[kx].values()))
for k in T[kx].keys():
T[kx][k] = T[kx][k]/s
 
return T
 
 T = convertFreqIntoProb(T)
 print(T)
 #{'llo ': {'h': 1.0}, 'ello': {' ': 1.0}, 'o he': {'l': 1.0}, 'lo h': {'e': 1.0}, 'hell': {'i': 0.3333333333333333, 'o': 0.6666666666666666}, ' hel': {'l': 1.0}}

Penjelasan ringkas:

Tambahkan nilai kekerapan kunci tertentu, dan kemudian bahagikan setiap nilai kekerapan kunci ini dengan nilai tambah untuk mendapatkan kebarangkalian.

3. Muatkan set data

Seterusnya, korpus latihan sebenar akan dimuatkan. Anda boleh menggunakan sebarang dokumen teks panjang (.txt) yang anda mahukan.

Untuk kesederhanaan ucapan politik akan digunakan untuk menyediakan perbendaharaan kata yang mencukupi untuk mengajar model kami.

 text_path = "train_corpus.txt"
 def load_text(filename):
with open(filename,encoding='utf8') as f:
return f.read().lower()
 
 text = load_text(text_path)
 print('Loaded the dataset.')

Set data ini boleh menyediakan peristiwa yang mencukupi untuk projek sampel kami untuk membuat ramalan yang agak tepat. Seperti semua pembelajaran mesin, korpus latihan yang lebih besar akan menghasilkan ramalan yang lebih tepat.

4. Bina rantai Markov

Mari kita bina rantai Markov dan kaitkan kebarangkalian dengan setiap aksara. Fungsi generateTable() dan convertFreqIntoProb() yang dibuat dalam langkah 1 dan 2 akan digunakan di sini untuk membina model Markov.

 def MarkovChain(text,k=4):
T = generateTable(text,k)
T = convertFreqIntoProb(T)
return T
 
 model = MarkovChain(text)

Baris 1, mencipta kaedah untuk menjana model Markov. Kaedah ini menerima korpus teks dan nilai K, iaitu nilai yang memberitahu model Markov untuk mempertimbangkan aksara K dan meramalkan aksara seterusnya. Baris 2, jadual carian dijana dengan menyediakan korpus teks dan K kepada kaedah generateTable(), yang kami buat dalam bahagian sebelumnya. Baris 3 menukar frekuensi kepada nilai kebarangkalian menggunakan kaedah convertFreqIntoProb(), yang juga kami cipta dalam pelajaran sebelumnya.

5. Pensampelan Teks

Buat fungsi pensampelan yang menggunakan perkataan belum selesai (ctx), model rantai Markov (model) dalam langkah 4 dan asas untuk membentuk perkataan Bilangan aksara ( k).

Kami akan menggunakan fungsi ini untuk mencuba konteks yang diluluskan dan mengembalikan aksara yang mungkin seterusnya dan menentukan kebarangkalian bahawa ia adalah aksara yang betul.

 import numpy as np
 
 def sample_next(ctx,model,k):
 
ctx = ctx[-k:]
if model.get(ctx) is None:
return " "
possible_Chars = list(model[ctx].keys())
possible_values = list(model[ctx].values())
 
print(possible_Chars)
print(possible_values)
 
return np.random.choice(possible_Chars,p=possible_values)
 
 sample_next("commo",model,4)
 
 #['n']
 #[1.0]

Penjelasan kod:

Fungsi sample_next menerima tiga parameter: ctx, model dan nilai k.

ctx ialah teks yang digunakan untuk menjana beberapa teks baharu. Tetapi di sini hanya aksara K terakhir dalam ctx akan digunakan oleh model untuk meramalkan aksara seterusnya dalam jujukan. Sebagai contoh, kita lulus biasa, K = 4, dan teks yang model gunakan untuk menjana aksara seterusnya ialah ommo, kerana model Markov hanya menggunakan sejarah sebelumnya.

Pada baris 9 dan 10, aksara yang mungkin dan nilai kebarangkaliannya dicetak, kerana aksara ini juga terdapat dalam model kami. Kami mendapat watak ramalan seterusnya ialah n, dengan kebarangkalian 1.0. Memandangkan perkataan commo lebih berkemungkinan menjadi lebih biasa selepas menjana aksara seterusnya

pada baris 12, kami mengembalikan aksara berdasarkan nilai kebarangkalian yang dibincangkan di atas.

6. Hasilkan teks

Akhirnya gabungkan semua fungsi di atas untuk menghasilkan beberapa teks.

def generateText(starting_sent,k=4,maxLen=1000):
 
 sentence = starting_sent
ctx = starting_sent[-k:]
 
for ix in range(maxLen):
next_prediction = sample_next(ctx,model,k)
sentence += next_prediction
ctx = sentence[-k:]
return sentence
 
 print("Function Created Successfully!")
 
 text = generateText("dear",k=4,maxLen=2000)
 print(text)

Hasilnya adalah seperti berikut:

dear country brought new consciousness. i heartily great service of their lives, our country, many of tricoloring a color flag on their lives independence today.my devoted to be oppression of independence.these day the obc common many country, millions of oppression of massacrifice of indian whom everest.
 my dear country is not in the sevents went was demanding and nights by plowing in the message of the country is crossed, oppressed, women, to overcrowding for years of the south, it is like the ashok chakra of constitutional states crossed, deprived, oppressions of freedom, i bow my heart to proud of our country.my dear country, millions under to be a hundred years of the south, it is going their heroes.

Fungsi di atas menerima tiga parameter: perkataan permulaan teks yang dihasilkan, nilai K dan panjang aksara maksimum bagi teks yang diperlukan. Menjalankan kod akan menghasilkan teks 2000 aksara bermula dengan "sayang".

Walaupun ucapan ini mungkin tidak begitu masuk akal, kata-kata itu lengkap dan sering meniru pola yang biasa dalam perkataan.

Apa yang perlu dipelajari seterusnya

Ini ialah projek penjanaan teks mudah. Gunakan projek ini untuk mengetahui cara pemprosesan bahasa semula jadi dan rantai Markov berfungsi dalam tindakan, yang boleh anda gunakan semasa anda meneruskan perjalanan pembelajaran mendalam anda.

Artikel ini hanyalah untuk memperkenalkan projek percubaan yang dijalankan oleh rantaian Markov, kerana ia tidak akan memainkan sebarang peranan dalam aplikasi sebenar Jika anda ingin mendapatkan kesan penjanaan teks yang lebih baik, maka sila pelajari GPT- 3 alatan tersebut.

Atas ialah kandungan terperinci Membina penjana teks menggunakan rantai Markov. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!