text: import json
  import numpy as np
  import tensorflow as tf
  from tensorflow import keras
  from tensorflow.keras.models import Sequential
  from tensorflow.keras.layers import Dense, Embedding, GlobalAveragePooling1D
  from tensorflow.keras.preprocessing.text import Tokenizer
  from tensorflow.keras.preprocessing.sequence import pad_sequences
  from sklearn.preprocessing import LabelEncoder
  
  with open('intents.json',encoding='utf-8', errors='ignore') as file:
      data = json.load(file, strict=False)
  
  training_sentences = []
  training_labels = []
  labels = []
  responses = []
  
  
  for intent in data['intents']:
      for pattern in intent['patterns']:
          training_sentences.append(str(pattern).lower())
          training_labels.append(str(intent['tag']).lower())
      responses.append(str(intent['responses']).lower())
  
      if intent['tag'] not in labels:
          labels.append(str(intent['tag']).lower())
  
  num_classes = len(labels)
  
  lbl_encoder = LabelEncoder()
  lbl_encoder.fit(training_labels)
  training_labels = lbl_encoder.transform(training_labels)
  
  vocab_size = 1500
  embedding_dim = 16
  max_len = 20
  oov_token = "<OOV>"
  
  tokenizer = Tokenizer(num_words=vocab_size, oov_token=oov_token)
  tokenizer.fit_on_texts(training_sentences)
  word_index = tokenizer.word_index
  sequences = tokenizer.texts_to_sequences(training_sentences)
  padded_sequences = pad_sequences(sequences, truncating='post', maxlen=max_len)
  
  model = Sequential()
  model.add(Embedding(vocab_size, embedding_dim, input_length=max_len))
  model.add(GlobalAveragePooling1D())
  model.add(Dense(16, activation='relu'))
  model.add(Dense(16, activation='relu'))
  model.add(Dense(num_classes, activation='softmax'))
  
  model.compile(loss='sparse_categorical_crossentropy',
                optimizer='adam', metrics=['accuracy'])
  
  model.summary()
  epochs = 2500
  history = model.fit(padded_sequences, np.array(training_labels), epochs=epochs)
  
  
  def test(input_lst,output):
      res = []
      for inp in input_lst:
          result = model.predict(keras.preprocessing.sequence.pad_sequences(tokenizer.texts_to_sequences([inp]),
                                              truncating='post', maxlen=max_len))
          #print(result)
          #print('max : ',np.argmax(result))
          res.append(np.argmax(result))
      count = 0
      for i in res:
          for j in output:
              if str(i) == str(j):
                  count += 1
                  break
      return count
  
  # to save the trained model
  model.save("chat_model.h5")
  
  import pickle
  
  # to save the fitted tokenizer
  with open('tokenizer.pickle', 'wb') as handle:
      pickle.dump(tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)
  
  # to save the fitted label encoder
  with open('label_encoder.pickle', 'wb') as ecn_file:
      pickle.dump(lbl_encoder, ecn_file, protocol=pickle.HIGHEST_PROTOCOL)
  