How much time we have spent in order to learn ‘ABCD..’ it’s about a year. Now, we are living in the era of machines and assume your machine asks you to teach ‘Hindi’ –the fourth most speaking language around the world. With the help of deep learning, it is too easy and effective.
So moving to the coding part, assume all characters of Hindi language,
devnagri=”कखगघङचछजझञटठडढणतथदधनपफबभमयरलवशषस”
import numpy as np
Then prepare samples;
char_to_int = dict((c, i) for i, c in enumerate(devnagri))
int_to_char = dict((i, c) for i, c in enumerate(devnagri))
# prepare the dataset of input to output pairs encoded as integers
num_inputs = 1000
max_len = 5
dataX = []
dataY = []
for i in range(num_inputs):
start = np.random.randint(len(devnagri)-2)
end = np.random.randint(start, min(start+max_len,len(devnagri)-1))
sequence_in = devnagri[start:end+1]
sequence_out = devnagri[end + 1]
dataX.append([char_to_int[char] for char in sequence_in])
dataY.append(char_to_int[sequence_out])
print(sequence_in, ‘->’, sequence_out)
output:
रल -> व रलवशष -> स खगघङच -> छ छ -> ज ङचछज -> झ ढणतथद -> ध झञटठड -> ढ कखग -> घ ठ -> ड चछज -> झ रलव -> श ण -> त शष -> स घङच -> छ पफबभम -> य मयरलव -> श टठडढ -> ण बभ -> म जझञट -> ठ रलव -> श कखगघ -> ङ वशष -> स यरल -> व ब -> भ दधनप -> फ ङचछ -> ज मय -> र म -> य झञटठ -> ड झञट -> ठ यरलवश -> ष लव -> श खगघ -> ङ ठड -> ढ तथद -> ध थदधन -> प भमयरल -> व मयर -> ल मय -> र थदध -> न ढणत -> थ ठड -> ढ ट -> ठ धनपफ -> ब जझञट -> ठ ट -> ठ यर -> ल थदध -> न ढणतथद -> ध ङ -> च खगघ -> ङ णतथ -> द ञटठडढ -> ण वशष -> स त -> थ लव -> श बभमयर -> ल दधनप -> फ ञटठ -> ड डढ -> ण ढ -> ण वश -> ष ड -> ढ धनपफब -> भ ङ -> च झञट -> ठ भमयरल -> व जझञट -> ठ रलवश -> ष तथद -> ध ट -> ठ छजझ -> ञ थ -> द णतथदध -> न जझञट -> ठ नपफब -> भ यरलवश -> ष ढणतथ -> द झञ -> ट झञटठ -> ड ख -> ग ठडढणत -> थ फबभमय -> र चछज -> झ नपफब -> भ बभम -> य पफब -> भ णतथ -> द ङ -> च कखगघ -> ङ चछजझ -> ञ दधनप -> फ टठ -> ड ठडढणत -> थ वश -> ष शष -> स डढणतथ -> द पफब -> भ तथदध -> न भमयरल -> व शष -> स रल -> व ब -> भ शष -> स घङचछ -> ज ञटठडढ -> ण ल -> व यरल -> व न -> प प -> फ ठ -> ड थदधन -> प णतथदध -> न जझञटठ -> ड यरल -> व श -> ष ङचछज -> झ पफब -> भ धनपफब -> भ फबभमय -> र थदधन -> प छजझञट -> ठ ढ -> ण प -> फ पफबभम -> य बभमय -> र पफब -> भ धनपफब -> भ थदधन -> प जझञ -> ट रल -> व ङ -> च घ -> ङ झञ -> ट नपफबभ -> म खग -> घ नपफब -> भ चछजझञ -> ट तथदध -> न णतथ -> द च -> छ धनपफब -> भ खगघङ -> च ख -> ग खग -> घ लवश -> ष थदधन -> प गघङच -> छ लव -> श झञ -> ट ध -> न नपफबभ -> म खगघङच -> छ च -> छ तथद -> ध शष -> स ठडढ -> ण बभम -> य मयरल -> व श -> ष झञ -> ट श -> ष ञट -> ठ ञटठ -> ड प -> फ झञटठ -> ड जझञट -> ठ ङ -> च कखगघङ -> च तथदधन -> प गघङ -> च फबभम -> य फब -> भ छजझञट -> ठ णतथद -> ध झ -> ञ म -> य कख -> ग टठड -> ढ थदध -> न ङचछजझ -> ञ फबभम -> य म -> य छजझ -> ञ नप -> फ नपफ -> ब भ -> म घङचछ -> ज ल -> व यरल -> व प -> फ डढ -> ण ज -> झ छजझञ -> ट तथदधन -> प थदधन -> प त -> थ ढणतथद -> ध फबभमय -> र ञटठडढ -> ण घङ -> च धनपफब -> भ गघङ -> च ज -> झ जझञट -> ठ घङचछज -> झ ढणत -> थ ब -> भ बभमय -> र ग -> घ तथद -> ध ड -> ढ ड -> ढ फब -> भ ल -> व क -> ख व -> श मयरल -> व गघङ -> च टठ -> ड गघङ -> च ब -> भ खग -> घ घङ -> च दधन -> प वश -> ष छ -> ज छज -> झ टठड -> ढ ङचछज -> झ झञट -> ठ फ -> ब ङचछज -> झ बभ -> म ञ -> ट छज -> झ ङचछ -> ज नपफब -> भ पफब -> भ फबभमय -> र पफब -> भ ङच -> छ ङचछजझ -> ञ ङचछजझ -> ञ खगघ -> ङ म -> य गघ -> ङ गघङचछ -> ज य -> र गघङच -> छ घङच -> छ पफ -> ब डढण -> त ल -> व झ -> ञ धनपफब -> भ फबभम -> य ज -> झ ध -> न डढ -> ण ञटठ -> ड खगघ -> ङ पफ -> ब वश -> ष गघङचछ -> ज गघङ -> च ड -> ढ डढ -> ण खगघङ -> च ल -> व टठडढ -> ण तथद -> ध गघङचछ -> ज फब -> भ व -> श लवशष -> स पफबभ -> म झञटठड -> ढ ञटठडढ -> ण ठ -> ड ङच -> छ झञटठ -> ड फबभ -> म ङचछ -> ज पफबभ -> म कखगघ -> ङ डढण -> त पफबभ -> म नपफबभ -> म ठड -> ढ चछ -> ज थद -> ध कख -> ग ठडढण -> त जझञटठ -> ड ठडढणत -> थ श -> ष झञटठड -> ढ नपफब -> भ घङचछ -> ज टठडढण -> त घङचछ -> ज छजझञट -> ठ द -> ध ज -> झ ठडढ -> ण ठडढण -> त झञटठ -> ड च -> छ लवश -> ष पफब -> भ वशष -> स लव -> श घ -> ङ शष -> स जझञ -> ट झञटठ -> ड म -> य तथद -> ध कखग -> घ कखगघङ -> च च -> छ भम -> य ज -> झ ड -> ढ
Now, start creating pad sequencing as we have different length samples….
from keras.preprocessing.sequence import pad_sequences
X = pad_sequences(dataX, maxlen=max_len, dtype=’float32′)
Now reshape it,
from keras.utils import np_utils
X = np.reshape(X, (X.shape[0], max_len, 1))
# normalize
X = X / float(len(devnagri))
# one hot encode the output variable
y = np_utils.to_categorical(dataY)
Now build the model,
from keras.models import Sequential
from keras.layers import LSTM
from keras.layers import Dense
model = Sequential()
model.add(LSTM(32, input_shape=(X.shape[1], 1)))
model.add(Dense(y.shape[1], activation=’softmax’))
model.compile(loss=’categorical_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])
model.fit(X, y, epochs=200, batch_size=10, verbose=1)
# summarize performance of the model
scores = model.evaluate(X, y, verbose=0)
print(“Model Accuracy: %.2f%%” % (scores[1]*100))
output:
Epoch 196/200 1000/1000 [==============================] - 0s - loss: 0.6057 - acc: 0.8330 Epoch 197/200 1000/1000 [==============================] - 0s - loss: 0.6038 - acc: 0.8220 Epoch 198/200 1000/1000 [==============================] - 0s - loss: 0.6013 - acc: 0.8330 Epoch 199/200 1000/1000 [==============================] - 0s - loss: 0.5995 - acc: 0.8180 Epoch 200/200 1000/1000 [==============================] - 0s - loss: 0.6015 - acc: 0.8110 Model Accuracy: 83.50%
Now test the outcome:
for i in range(20):
pattern_index = numpy.random.randint(len(dataX))
#print(pattern_index)
pattern = dataX[pattern_index]
x = pad_sequences([pattern], maxlen=max_len, dtype=’float32′)
x = numpy.reshape(x, (1, max_len, 1))
x = x / float(len(devnagri))
prediction = model.predict(x, verbose=0)
index = numpy.argmax(prediction)
result = int_to_char[index]
seq_in = [int_to_char[value] for value in pattern]
print(seq_in, “->”, result)
Results:
In this way, we can train any language to our machines.