#!/usr/bin/env python

# coding: utf-8

# In[1]:

import random

import numpy as np

import pandas as pd

# Visualisation imports

import matplotlib.pyplot as plt

import seaborn as sns

# Scikit learn for preprocessing

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import LabelEncoder

# Keras Imports - CNN

from keras.models import Sequential

from keras.layers import Dense, Conv2D, MaxPool2D, Flatten, Dropout

from keras.optimizers import Adam

from keras.utils.np_utils import to_categorical

# In[2]:

import os

os.chdir("E:\\devanagari-character-set")

# In[3]:

data = pd.read_csv("data.csv")

# In[4]:

data.groupby("character").count()

# In[5]:

char_names = data.character.unique()

rows =10;columns=5;

fig, ax = plt.subplots(rows,columns, figsize=(8,16))

for row in range(rows):

for col in range(columns):

ax[row,col].set_axis_off()

if columns*row+col < len(char_names):

x = data[data.character==char_names[columns*row+col]].iloc[0,:-1].values.reshape(32,32)

x = x.astype("float64")

x/=255

ax[row,col].imshow(x, cmap="binary")

ax[row,col].set_title(char_names[columns*row+col].split("_")[-1])

plt.subplots_adjust(wspace=1, hspace=1)

plt.show()

# In[6]:

char_names

# In[7]:

plt.hist(data.iloc[0,:-1])

plt.show()

# In[8]:

X = data.values[:,:-1]/255.0

Y = data["character"].values

# In[9]:

#Let us minimize the memory consumption

del data

n_classes = 46

# In[10]:

# Let's split the data into train and test data

x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.30, random_state=42)

# Encode the categories

le = LabelEncoder()

y_train = le.fit_transform(y_train)

y_test = le.transform(y_test)

y_train = to_categorical(y_train, n_classes)

y_test = to_categorical(y_test, n_classes)

# In[11]:

img_height_rows = 32

img_width_cols = 32

# In[12]:

im_shape = (img_height_rows, img_width_cols, 1)

x_train = x_train.reshape(x_train.shape[0], *im_shape) # Python TIP :the * operator unpacks the tuple

x_test = x_test.reshape(x_test.shape[0], *im_shape)

# In[13]:

#CNN Model - Sequential Modelling

cnn = Sequential()

# In[14]:

kernelSize = (3, 3)

ip_activation = 'relu'

ip_conv_0 = Conv2D(filters=32, kernel_size=kernelSize, input_shape=im_shape, activation=ip_activation)

cnn.add(ip_conv_0)

# In[15]:

# Add the next Convolutional+Activation layer

ip_conv_0_1 = Conv2D(filters=64, kernel_size=kernelSize, activation=ip_activation)

cnn.add(ip_conv_0_1)

# Add the Pooling layer

pool_0 = MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding="same")

cnn.add(pool_0)

# In[16]:

ip_conv_1 = Conv2D(filters=64, kernel_size=kernelSize, activation=ip_activation)

cnn.add(ip_conv_1)

ip_conv_1_1 = Conv2D(filters=64, kernel_size=kernelSize, activation=ip_activation)

cnn.add(ip_conv_1_1)

pool_1 = MaxPool2D(pool_size=(2, 2), strides=(2, 2), padding="same")

cnn.add(pool_1)

# In[17]:

# Let's deactivate around 20% of neurons randomly for training

drop_layer_0 = Dropout(0.2)

cnn.add(drop_layer_0)

# In[18]:

flat_layer_0 = Flatten()

cnn.add(Flatten())

# In[19]:

# Now add the Dense layers

h_dense_0 = Dense(units=128, activation=ip_activation, kernel_initializer='uniform')

cnn.add(h_dense_0)

# Let's add one more before proceeding to the output layer

h_dense_1 = Dense(units=64, activation=ip_activation, kernel_initializer='uniform')

cnn.add(h_dense_1)

# In[20]:

op_activation = 'softmax'

output_layer = Dense(units=n_classes, activation=op_activation, kernel_initializer='uniform')

cnn.add(output_layer)

# In[21]:

opt = 'adam'

loss = 'categorical_crossentropy'

metrics = ['accuracy']

# Compile the classifier using the configuration we want

cnn.compile(optimizer=opt, loss=loss, metrics=metrics)

# In[22]:

print(cnn.summary())

# In[23]:

history = cnn.fit(x_train, y_train,

batch_size=32, epochs=10,

validation_data=(x_test, y_test))

# In[24]:

scores = cnn.evaluate(x_test, y_test, verbose=0)

print("Accuracy: %.2f%%" % (scores[1]*100))

# In[25]:

# Accuracy

print(history)

fig1, ax_acc = plt.subplots()

plt.plot(history.history['acc'])

plt.plot(history.history['val_acc'])

plt.xlabel('Epoch')

plt.ylabel('Accuracy')

plt.title('Model - Accuracy')

plt.legend(['Training', 'Validation'], loc='lower right')

plt.show()

# In[26]:

# Loss

fig2, ax_loss = plt.subplots()

plt.xlabel('Epoch')

plt.ylabel('Loss')

plt.title('Model- Loss')

plt.legend(['Training', 'Validation'], loc='upper right')

plt.plot(history.history['loss'])

plt.plot(history.history['val_loss'])

plt.show()

# In[30]:

model_json = cnn.to_json()

with open("model.json", "w") as json_file:

json_file.write(model_json)

# serialize weights to HDF5

cnn.save_weights("model.h5")

print("Saved model to disk")

# In[32]:

model_json

# In[ ]: