import nltk

# nltk.download('punkt')

# nltk.download('wordnet')

from nltk.stem import WordNetLemmatizer

from nltk.corpus import stopwords

lemmatizer = WordNetLemmatizer()

import json

import pickle

from sklearn.tree import DecisionTreeClassifier

from sklearn.model_selection import train_test_split

from sklearn.metrics import accuracy_score

import numpy as np

from keras.models import Sequential

from keras.layers import Dense, Activation, Dropout

from keras.optimizers import SGD

import random

words=[]

classes = []

documents = []

ignore_words = ['?', '!', '.',',']

stop_words = list(stopwords.words('english'))

data_file = open('intents.json').read()

intents = json.loads(data_file)

for intent in intents['intents']:

for pattern in intent['patterns']:

# take each word and tokenize it

w = nltk.word_tokenize(pattern)

#filter out stop words

words.extend(word for word in w if word not in stop_words)

# adding documents

documents.append((w, intent['tag']))

# adding classes to our class list

if intent['tag'] not in classes:

classes.append(intent['tag'])

words = [lemmatizer.lemmatize(w.lower()) for w in words if w not in ignore_words]

words = sorted(list(set(words)))

classes = sorted(list(set(classes)))

print (len(documents), "documents")

print (len(classes), "classes", classes)

print (len(words), "unique lemmatized words", words)

pickle.dump(words,open('words.pkl','wb'))

pickle.dump(classes,open('classes.pkl','wb'))

# initializing training data

training = []

output_empty = [0] * len(classes)

for doc in documents:

# initializing bag of words

bag = []

# list of tokenized words for the pattern

pattern_words = doc[0]

# lemmatize each word - create base word, in attempt to represent related words

pattern_words = [lemmatizer.lemmatize(word.lower()) for word in pattern_words]

# create our bag of words array with 1, if word match found in current pattern

for w in words:

bag.append(1) if w in pattern_words else bag.append(0)

# record the corrseponding class for each pattern

output_row = list(output_empty)

output_row[classes.index(doc[1])] = 1

#record feature in a pattern using bag of words and its class label

training.append([bag, output_row])

# shuffle our features and turn into np.array

random.shuffle(training)

training = np.array(training)

# create train and test lists. X - patterns, Y - intents

train_x = list(training[:,0])

train_y = list(training[:,1])

print("Training data created")

x_train, x_test, y_train, y_test = train_test_split(train_x, train_y, test_size=0.33, random_state=42)

#Decision Tree Model

clf1 = DecisionTreeClassifier()

clf = clf1.fit(x_train,y_train)

clf_predict = clf.predict(x_test)

print(clf.score(x_train, y_train))

print ("cross result========")

print(accuracy_score(y_test, clf_predict))

# Neural Network Model

model = Sequential()

model.add(Dense(128, input_shape=(len(train_x[0]),), activation='relu'))

model.add(Dropout(0.5))

model.add(Dense(64, activation='relu'))

model.add(Dropout(0.5))

model.add(Dense(len(train_y[0]), activation='softmax'))

# Compile model. Stochastic gradient descent with Nesterov accelerated gradient gives good results for this model

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)

model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])

#fitting and saving the model

hist = model.fit(np.array(train_x), np.array(train_y), epochs=200, batch_size=5, verbose=1)

model.save('chatbot_model.h5', hist)

print("model created")