CaesarAINL Deployed Maybe

.gitattributes

@@ -0,0 +1,42 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+glove.6B.300d_should_be_here.txt filter=lfs diff=lfs merge=lfs -text
+glove.6B.300d.txt filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text
+*.index filter=lfs diff=lfs merge=lfs -text
+variables.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+vocab.txt filter=lfs diff=lfs merge=lfs -text
+caesarintro.mp3 filter=lfs diff=lfs merge=lfs -text

DockerFile

@@ -0,0 +1,14 @@
+FROM tensorflow/tensorflow:latest-gpu-jupyter
+
+#VOLUME CaesarAINL CaesarAINL
+WORKDIR /CaesarAINL 
+
+ADD CaesarAINL /CaesarAINL 
+
+RUN pip install flask flask_cors tensorflow_hub tensorflow_text scikit-learn tqdm matplotlib gunicorn
+
+EXPOSE 5000 
+#80
+
+ENTRYPOINT [ "python" ]
+CMD ["app.py"]

Procfile

@@ -0,0 +1 @@
+web: gunicorn app:app

README.md

@@ -0,0 +1,8 @@
+---
+title: CaesarAINL
+emoji: 🏢
+colorFrom: purple
+colorTo: blue
+sdk: docker
+pinned: false
+---

app.py

@@ -0,0 +1,29 @@
+from flask import Flask,request
+from flask_cors import cross_origin
+import os
+from caesarinfer import CaesarNL
+app = Flask(__name__)
+
+@app.route("/",methods=["GET"])
+@cross_origin()
+def caesarhome():
+    return "Caeser: How can I help you sir?"
+
+@app.route("/caesarapi",methods=["POST","GET"])
+@cross_origin()
+def caesarapi():
+    if request.method == "GET":
+        return "Caeser: Hello sir, this is the CaesarAIAPI"
+    elif request.method == "POST":
+        user_input_json = request.get_json()
+        
+        print("Caesar Processing...")
+        caesarResponse,intents = CaesarNL.run([user_input_json["caesarapi"]])
+        print("Caesar Processed.")
+        print(caesarResponse,"intent:",intents)
+
+        return {"caesarmessage":{"caesarResponse":caesarResponse,"intent":intents}}
+
+if __name__ == "__main__":
+    port = int(os.environ.get('PORT', 5000)) # 80
+    app.run(debug=True,host="0.0.0.0",port=port) # 

bert tutorial/caesarbert.py

@@ -0,0 +1,476 @@
+# -*- coding: utf-8 -*-
+"""intent_classification_with_bert.ipynb
+
+Automatically generated by Colaboratory.
+
+Original file is located at
+    https://colab.research.google.com/drive/1gTNCoFmqJslnlc3lSbOTqsBz_UjJarS5
+
+# Intent Classification with BERT
+
+This notebook demonstrates the fine-tuning of BERT to perform intent classification.
+Intent classification tries to map given instructions (sentence in natural language) to a set of predefined intents. 
+
+## What you will learn
+
+- Load data from csv and preprocess it for training and test
+- Load a BERT model from TensorFlow Hub
+- Build your own model by combining BERT with a classifier
+- Train your own model, fine-tuning BERT as part of that
+- Save your model and use it to recognize the intend of instructions
+
+## About BERT
+
+[BERT](https://arxiv.org/abs/1810.04805) and other Transformer encoder architectures have been shown to be successful on a variety of tasks in NLP (natural language processing). They compute vector-space representations of natural language that are suitable for use in deep learning models. The BERT family of models uses the Transformer encoder architecture to process each token of input text in the full context of all tokens before and after, hence the name: Bidirectional Encoder Representations from Transformers. 
+
+BERT models are usually pre-trained on a large corpus of text, then fine-tuned for specific tasks.
+
+## Setup
+"""
+
+import os
+#import shutil
+import pandas as pd
+
+import tensorflow as tf
+import tensorflow_hub as hub
+import tensorflow_text as text
+import seaborn as sns
+from pylab import rcParams
+
+import matplotlib.pyplot as plt
+tf.get_logger().setLevel('ERROR')
+
+sns.set(style='whitegrid', palette='muted', font_scale=1.2)
+HAPPY_COLORS_PALETTE = ["#01BEFE", "#FFDD00", "#FF7D00", "#FF006D", "#ADFF02", "#8F00FF"]
+sns.set_palette(sns.color_palette(HAPPY_COLORS_PALETTE))
+rcParams['figure.figsize'] = 12, 8
+import warnings
+warnings.filterwarnings("ignore")
+
+"""## Data Access
+The data contains various user queries categorized into seven intents. It is hosted on [GitHub](https://github.com/snipsco/nlu-benchmark/tree/master/2017-06-custom-intent-engines) and is first presented in [this paper](https://arxiv.org/abs/1805.10190). In the list below the classes and an example for each class is given:
+
+* `class`: SearchCreativeWork - `example`:*play hell house song*
+* `class`: GetWeather - `example`: *is it windy in boston, mb right now*
+* `class`: BookRestaurant - `example`: *book a restaurant for eight people in six years*
+* `class`: PlayMusic - `example`: *play the song little robin redbreast*
+* `class`: AddToPlaylist - `example`: *add step to me to the 50 clásicos playlist*
+* `class`: RateBook - `example`: *give 6 stars to of mice and men*
+* `class`: SearchScreeningEvent - `example` : *find fish story*
+
+Data can be downloaded from a Google Drive by applying [gdown](https://pypi.org/project/gdown/). In the following code cells the download is invoked only if the corresponding file, does not yet exist at the corresponding location.
+"""
+
+datafolder=""
+
+trainfile=datafolder+"train.csv"
+testfile=datafolder+"test.csv"
+validfile=datafolder+"valid.csv"
+
+"""Next, the downloaded .csv-files for training, validation and test are imported into pandas dataframes:"""
+
+traindf = pd.read_csv(trainfile)
+validdf = pd.read_csv(validfile)
+testdf = pd.read_csv(testfile)
+
+traindf.head()
+
+"""Training data contains 13084 instructions:"""
+
+traindf.shape
+
+trainfeatures=traindf.copy()
+trainlabels=trainfeatures.pop("intent")
+
+trainfeatures=trainfeatures.values
+
+"""Distribution of class-labels in training-data:"""
+
+#chart = sns.countplot(trainlabels, palette=HAPPY_COLORS_PALETTE)
+#plt.title("Number of texts per intent")
+#chart
+#`chart.set_xticklabels(chart.get_xticklabels(), rotation=30, horizontalalignment='right')
+
+"""One-Hot-Encoding of class-labels:"""
+
+from sklearn.preprocessing import LabelBinarizer
+
+binarizer=LabelBinarizer()
+trainlabels=binarizer.fit_transform(trainlabels.values)
+
+trainlabels.shape
+
+"""Preprocess test- and validation data in the same way as it has been done for training-data:"""
+
+testfeatures=testdf.copy()
+testlabels=testfeatures.pop("intent")
+validfeatures=validdf.copy()
+validlabels=validfeatures.pop("intent")
+
+testfeatures=testfeatures.values
+validfeatures=validfeatures.values
+
+testlabels=binarizer.transform(testlabels.values)
+validlabels=binarizer.transform(validlabels.values)
+
+"""## Loading models from TensorFlow Hub
+
+Here you can choose which BERT model you will load from TensorFlow Hub and fine-tune. There are multiple BERT models available.
+
+  - [BERT-Base](https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3), [Uncased](https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3) and [seven more models](https://tfhub.dev/google/collections/bert/1) with trained weights released by the original BERT authors.
+  - [Small BERTs](https://tfhub.dev/google/collections/bert/1) have the same general architecture but fewer and/or smaller Transformer blocks, which lets you explore tradeoffs between speed, size and quality.
+  - [ALBERT](https://tfhub.dev/google/collections/albert/1): four different sizes of "A Lite BERT" that reduces model size (but not computation time) by sharing parameters between layers.
+  - [BERT Experts](https://tfhub.dev/google/collections/experts/bert/1): eight models that all have the BERT-base architecture but offer a choice between different pre-training domains, to align more closely with the target task.
+  - [Electra](https://tfhub.dev/google/collections/electra/1) has the same architecture as BERT (in three different sizes), but gets pre-trained as a discriminator in a set-up that resembles a Generative Adversarial Network (GAN).
+  - BERT with Talking-Heads Attention and Gated GELU [[base](https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_base/1), [large](https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_large/1)] has two improvements to the core of the Transformer architecture.
+
+The model documentation on TensorFlow Hub has more details and references to the
+research literature. Follow the links above, or click on the [`tfhub.dev`](http://tfhub.dev) URL
+printed after the next cell execution.
+
+The suggestion is to start with a Small BERT (with fewer parameters) since they are faster to fine-tune. If you like a small model but with higher accuracy, ALBERT might be your next option. If you want even better accuracy, choose
+one of the classic BERT sizes or their recent refinements like Electra, Talking Heads, or a BERT Expert.
+
+Aside from the models available below, there are [multiple versions](https://tfhub.dev/google/collections/transformer_encoders_text/1) of the models that are larger and can yield even better accuracy but they are too big to be fine-tuned on a single GPU. You will be able to do that on the [Solve GLUE tasks using BERT on a TPU colab](https://www.tensorflow.org/tutorials/text/solve_glue_tasks_using_bert_on_tpu).
+
+You'll see in the code below that switching the tfhub.dev URL is enough to try any of these models, because all the differences between them are encapsulated in the SavedModels from TF Hub.
+"""
+
+bert_model_name = 'small_bert/bert_en_uncased_L-8_H-512_A-8' 
+map_name_to_handle = {
+    'bert_en_uncased_L-12_H-768_A-12':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3',
+    'bert_en_cased_L-12_H-768_A-12':
+        'https://tfhub.dev/tensorflow/bert_en_cased_L-12_H-768_A-12/3',
+    'bert_multi_cased_L-12_H-768_A-12':
+        'https://tfhub.dev/tensorflow/bert_multi_cased_L-12_H-768_A-12/3',
+    'small_bert/bert_en_uncased_L-2_H-128_A-2':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-128_A-2/1',
+    'small_bert/bert_en_uncased_L-2_H-256_A-4':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-256_A-4/1',
+    'small_bert/bert_en_uncased_L-2_H-512_A-8':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-512_A-8/1',
+    'small_bert/bert_en_uncased_L-2_H-768_A-12':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-768_A-12/1',
+    'small_bert/bert_en_uncased_L-4_H-128_A-2':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-128_A-2/1',
+    'small_bert/bert_en_uncased_L-4_H-256_A-4':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-256_A-4/1',
+    'small_bert/bert_en_uncased_L-4_H-512_A-8':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-512_A-8/1',
+    'small_bert/bert_en_uncased_L-4_H-768_A-12':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-768_A-12/1',
+    'small_bert/bert_en_uncased_L-6_H-128_A-2':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-128_A-2/1',
+    'small_bert/bert_en_uncased_L-6_H-256_A-4':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-256_A-4/1',
+    'small_bert/bert_en_uncased_L-6_H-512_A-8':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-512_A-8/1',
+    'small_bert/bert_en_uncased_L-6_H-768_A-12':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-768_A-12/1',
+    'small_bert/bert_en_uncased_L-8_H-128_A-2':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-128_A-2/1',
+    'small_bert/bert_en_uncased_L-8_H-256_A-4':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-256_A-4/1',
+    'small_bert/bert_en_uncased_L-8_H-512_A-8':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-512_A-8/1',
+    'small_bert/bert_en_uncased_L-8_H-768_A-12':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-768_A-12/1',
+    'small_bert/bert_en_uncased_L-10_H-128_A-2':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-128_A-2/1',
+    'small_bert/bert_en_uncased_L-10_H-256_A-4':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-256_A-4/1',
+    'small_bert/bert_en_uncased_L-10_H-512_A-8':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-512_A-8/1',
+    'small_bert/bert_en_uncased_L-10_H-768_A-12':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-768_A-12/1',
+    'small_bert/bert_en_uncased_L-12_H-128_A-2':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-128_A-2/1',
+    'small_bert/bert_en_uncased_L-12_H-256_A-4':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-256_A-4/1',
+    'small_bert/bert_en_uncased_L-12_H-512_A-8':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-512_A-8/1',
+    'small_bert/bert_en_uncased_L-12_H-768_A-12':
+        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-768_A-12/1',
+    'albert_en_base':
+        'https://tfhub.dev/tensorflow/albert_en_base/2',
+    'electra_small':
+        'https://tfhub.dev/google/electra_small/2',
+    'electra_base':
+        'https://tfhub.dev/google/electra_base/2',
+    'experts_pubmed':
+        'https://tfhub.dev/google/experts/bert/pubmed/2',
+    'experts_wiki_books':
+        'https://tfhub.dev/google/experts/bert/wiki_books/2',
+    'talking-heads_base':
+        'https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_base/1',
+}
+
+map_model_to_preprocess = {
+    'bert_en_uncased_L-12_H-768_A-12':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'bert_en_cased_L-12_H-768_A-12':
+        'https://tfhub.dev/tensorflow/bert_en_cased_preprocess/2',
+    'small_bert/bert_en_uncased_L-2_H-128_A-2':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-2_H-256_A-4':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-2_H-512_A-8':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-2_H-768_A-12':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-4_H-128_A-2':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-4_H-256_A-4':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-4_H-512_A-8':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-4_H-768_A-12':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-6_H-128_A-2':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-6_H-256_A-4':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-6_H-512_A-8':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-6_H-768_A-12':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-8_H-128_A-2':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-8_H-256_A-4':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-8_H-512_A-8':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-8_H-768_A-12':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-10_H-128_A-2':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-10_H-256_A-4':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-10_H-512_A-8':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-10_H-768_A-12':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-12_H-128_A-2':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-12_H-256_A-4':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-12_H-512_A-8':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'small_bert/bert_en_uncased_L-12_H-768_A-12':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'bert_multi_cased_L-12_H-768_A-12':
+        'https://tfhub.dev/tensorflow/bert_multi_cased_preprocess/2',
+    'albert_en_base':
+        'https://tfhub.dev/tensorflow/albert_en_preprocess/2',
+    'electra_small':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'electra_base':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'experts_pubmed':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'experts_wiki_books':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+    'talking-heads_base':
+        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',
+}
+
+tfhub_handle_encoder = map_name_to_handle[bert_model_name]
+tfhub_handle_preprocess = map_model_to_preprocess[bert_model_name]
+
+print(f'BERT model selected           : {tfhub_handle_encoder}')
+print(f'Preprocess model auto-selected: {tfhub_handle_preprocess}')
+
+"""## The preprocessing model
+
+Text inputs need to be transformed to numeric token ids and arranged in several Tensors before being input to BERT. TensorFlow Hub provides a matching preprocessing model for each of the BERT models discussed above, which implements this transformation using TF ops from the TF.text library. It is not necessary to run pure Python code outside your TensorFlow model to preprocess text.
+
+The preprocessing model must be the one referenced by the documentation of the BERT model, which you can read at the URL printed above. For BERT models from the drop-down above, the preprocessing model is selected automatically.
+
+Note: You will load the preprocessing model into a [hub.KerasLayer](https://www.tensorflow.org/hub/api_docs/python/hub/KerasLayer) to compose your fine-tuned model. This is the preferred API to load a TF2-style SavedModel from TF Hub into a Keras model.
+"""
+
+bert_preprocess_model = hub.KerasLayer(tfhub_handle_preprocess)
+
+"""Let's try the preprocessing model on some text and see the output:"""
+
+trainfeatures[0]
+
+text_test = trainfeatures[0]
+text_preprocessed = bert_preprocess_model(text_test)
+
+print(f'Keys       : {list(text_preprocessed.keys())}')
+print(f'Shape      : {text_preprocessed["input_word_ids"].shape}')
+print(f'Word Ids   : {text_preprocessed["input_word_ids"][0, :12]}')
+print(f'Input Mask : {text_preprocessed["input_mask"][0, :12]}')
+print(f'Type Ids   : {text_preprocessed["input_type_ids"][0, :12]}')
+
+"""As can be seen, there are 3 outputs from the preprocessing that a BERT model would use (`input_words_id`, `input_mask` and `input_type_ids`).
+
+Some other important points:
+- The input is truncated to 128 tokens. The number of tokens can be customized and you can see more details on the [Solve GLUE tasks using BERT on a TPU colab](https://www.tensorflow.org/tutorials/text/solve_glue_tasks_using_bert_on_tpu).
+- The `input_type_ids` only have one value (0) because this is a single sentence input. For a multiple sentence input, it would have one number for each input.
+
+Since this text preprocessor is a TensorFlow model, It can be included in your model directly.
+
+## Using the BERT model
+
+Before putting BERT into an own model, let's take a look at its outputs. You will load it from TF Hub and see the returned values.
+"""
+
+bert_model = hub.KerasLayer(tfhub_handle_encoder)
+
+bert_results = bert_model(text_preprocessed)
+
+print(f'Loaded BERT: {tfhub_handle_encoder}')
+print(f'Pooled Outputs Shape:{bert_results["pooled_output"].shape}')
+print(f'Pooled Outputs Values:{bert_results["pooled_output"][0, :12]}')
+print(f'Sequence Outputs Shape:{bert_results["sequence_output"].shape}')
+print(f'Sequence Outputs Values:{bert_results["sequence_output"][0, :12]}')
+
+"""The BERT models return a map with 3 important keys: `pooled_output`, `sequence_output`, `encoder_outputs`:
+
+- `pooled_output` to represent each input sequence as a whole. The shape is `[batch_size, H]`. You can think of this as an embedding for the entire movie review.
+- `sequence_output` represents each input token in the context. The shape is `[batch_size, seq_length, H]`. You can think of this as a contextual embedding for every token in the movie review.
+- `encoder_outputs` are the intermediate activations of the `L` Transformer blocks. `outputs["encoder_outputs"][i]` is a Tensor of shape `[batch_size, seq_length, 1024]` with the outputs of the i-th Transformer block, for `0 <= i < L`. The last value of the list is equal to `sequence_output`.
+
+For the fine-tuning you are going to use the `pooled_output` array.
+
+## Define your model
+
+You will create a very simple fine-tuned model, with the preprocessing model, the selected BERT model, one Dense and a Dropout layer.
+
+Note: for more information about the base model's input and output you can use just follow the model's url for documentation. Here specifically you don't need to worry about it because the preprocessing model will take care of that for you.
+"""
+
+def build_classifier_model():
+  text_input = tf.keras.layers.Input(shape=(), dtype=tf.string, name='text')
+  preprocessing_layer = hub.KerasLayer(tfhub_handle_preprocess, name='preprocessing')
+  encoder_inputs = preprocessing_layer(text_input)
+  encoder = hub.KerasLayer(tfhub_handle_encoder, trainable=True, name='BERT_encoder')
+  outputs = encoder(encoder_inputs)
+  net = outputs['pooled_output']
+  net = tf.keras.layers.Dropout(0.1)(net)
+  net = tf.keras.layers.Dense(7, activation=None, name='classifier')(net)
+  return tf.keras.Model(text_input, net)
+
+"""Let's check that the model runs with the output of the preprocessing model."""
+
+classifier_model = build_classifier_model()
+bert_raw_result = classifier_model(tf.constant(trainfeatures[0]))
+print(tf.keras.activations.softmax(bert_raw_result))
+
+"""The output is meaningless, of course, because the model has not been trained yet.
+
+Let's take a look at the model's structure.
+"""
+
+classifier_model.summary()
+
+"""## Model training
+
+You now have all the pieces to train a model, including the preprocessing module, BERT encoder, data, and classifier.
+
+Since this is a non-binary classification problem and the model outputs probabilities, you'll use `losses.CategoricalCrossentropy` loss function.
+"""
+
+loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
+metrics = tf.metrics.CategoricalAccuracy()
+
+"""### Loading the BERT model and training
+
+Using the `classifier_model` you created earlier, you can compile the model with the loss, metric and optimizer.
+"""
+
+epochs=5
+optimizer=tf.keras.optimizers.Adam(1e-5)
+classifier_model.compile(optimizer=optimizer,
+                         loss=loss,
+                         metrics=metrics)
+
+"""Note: training time will vary depending on the complexity of the BERT model you have selected."""
+
+print(f'Training model with {tfhub_handle_encoder}')
+history = classifier_model.fit(x=trainfeatures,y=trainlabels,
+                               validation_data=(validfeatures,validlabels),
+                               batch_size=32,
+                               epochs=epochs)
+classifier_model.save("CaesarAI.h5")
+
+"""### Evaluate the model
+
+Let's see how the model performs. Two values will be returned. Loss (a number which represents the error, lower values are better), and accuracy.
+"""
+
+loss, accuracy = classifier_model.evaluate(testfeatures,testlabels)
+
+print(f'Loss: {loss}')
+print(f'Accuracy: {accuracy}')
+
+"""### Plot the accuracy and loss over time
+
+Based on the `History` object returned by `model.fit()`. You can plot the training and validation loss for comparison, as well as the training and validation accuracy:
+"""
+
+history_dict = history.history
+print(history_dict.keys())
+
+acc = history_dict['categorical_accuracy']
+val_acc = history_dict['val_categorical_accuracy']
+loss = history_dict['loss']
+val_loss = history_dict['val_loss']
+
+epochs = range(1, len(acc) + 1)
+fig = plt.figure(figsize=(10, 8))
+fig.tight_layout()
+
+plt.subplot(2, 1, 1)
+# "bo" is for "blue dot"
+plt.plot(epochs, loss, 'r', label='Training loss')
+# b is for "solid blue line"
+plt.plot(epochs, val_loss, 'b', label='Validation loss')
+plt.title('Training and validation loss')
+plt.grid(True)
+# plt.xlabel('Epochs')
+plt.ylabel('Loss')
+plt.legend()
+
+plt.subplot(2, 1, 2)
+plt.plot(epochs, acc, 'r', label='Training acc')
+plt.plot(epochs, val_acc, 'b', label='Validation acc')
+plt.title('Training and validation accuracy')
+plt.grid(True)
+plt.xlabel('Epochs')
+plt.ylabel('Accuracy')
+plt.legend(loc='lower right')
+
+"""In this plot, the red lines represents the training loss and accuracy, and the blue lines are the validation loss and accuracy.
+
+Classifying arbitrary instructions:
+"""
+
+def print_my_examples(inputs, results):
+  result_for_printing = \
+    [f'input: {inputs[i]:<30} : estimated intent: {results[i]}'
+                         for i in range(len(inputs))]
+  print(*result_for_printing, sep='\n')
+  print()
+
+
+examples = [
+    'play a song from U2',  # this is the same sentence tried earlier
+    'Will it rain tomorrow',
+    'I like to hear greatist hits from beastie boys',
+    'I like to book a table for 3 persons',
+    '5 stars for machines like me'
+]
+
+results = tf.nn.softmax(classifier_model(tf.constant(examples)))
+
+binarizer.classes_
+
+intents=binarizer.inverse_transform(results.numpy())
+
+print_my_examples(examples, intents)
+

bert tutorial/intent_classification_with_bert.ipynb

@@ -0,0 +1,1239 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "IZ6SNYq_tVVC"
+   },
+   "source": [
+    "# Intent Classification with BERT\n",
+    "\n",
+    "This notebook demonstrates the fine-tuning of BERT to perform intent classification.\n",
+    "Intent classification tries to map given instructions (sentence in natural language) to a set of predefined intents. \n",
+    "\n",
+    "## What you will learn\n",
+    "\n",
+    "- Load data from csv and preprocess it for training and test\n",
+    "- Load a BERT model from TensorFlow Hub\n",
+    "- Build your own model by combining BERT with a classifier\n",
+    "- Train your own model, fine-tuning BERT as part of that\n",
+    "- Save your model and use it to recognize the intend of instructions\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "2PHBpLPuQdmK"
+   },
+   "source": [
+    "## About BERT\n",
+    "\n",
+    "[BERT](https://arxiv.org/abs/1810.04805) and other Transformer encoder architectures have been shown to be successful on a variety of tasks in NLP (natural language processing). They compute vector-space representations of natural language that are suitable for use in deep learning models. The BERT family of models uses the Transformer encoder architecture to process each token of input text in the full context of all tokens before and after, hence the name: Bidirectional Encoder Representations from Transformers. \n",
+    "\n",
+    "BERT models are usually pre-trained on a large corpus of text, then fine-tuned for specific tasks.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "SCjmX4zTCkRK"
+   },
+   "source": [
+    "## Setup\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-01-13T03:07:33.561260Z",
+     "iopub.status.busy": "2021-01-13T03:07:33.560567Z",
+     "iopub.status.idle": "2021-01-13T03:07:40.852309Z",
+     "shell.execute_reply": "2021-01-13T03:07:40.851601Z"
+    },
+    "id": "_XgTpm9ZxoN9"
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "#import shutil\n",
+    "import pandas as pd\n",
+    "\n",
+    "import tensorflow as tf\n",
+    "import tensorflow_hub as hub\n",
+    "import tensorflow_text as text\n",
+    "import seaborn as sns\n",
+    "from pylab import rcParams\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "tf.get_logger().setLevel('ERROR')\n",
+    "\n",
+    "sns.set(style='whitegrid', palette='muted', font_scale=1.2)\n",
+    "HAPPY_COLORS_PALETTE = [\"#01BEFE\", \"#FFDD00\", \"#FF7D00\", \"#FF006D\", \"#ADFF02\", \"#8F00FF\"]\n",
+    "sns.set_palette(sns.color_palette(HAPPY_COLORS_PALETTE))\n",
+    "rcParams['figure.figsize'] = 12, 8\n",
+    "import warnings\n",
+    "warnings.filterwarnings(\"ignore\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Data Access\n",
+    "The data contains various user queries categorized into seven intents. It is hosted on [GitHub](https://github.com/snipsco/nlu-benchmark/tree/master/2017-06-custom-intent-engines) and is first presented in [this paper](https://arxiv.org/abs/1805.10190). In the list below the classes and an example for each class is given:\n",
+    "\n",
+    "* `class`: SearchCreativeWork - `example`:*play hell house song*\n",
+    "* `class`: GetWeather - `example`: *is it windy in boston, mb right now*\n",
+    "* `class`: BookRestaurant - `example`: *book a restaurant for eight people in six years*\n",
+    "* `class`: PlayMusic - `example`: *play the song little robin redbreast*\n",
+    "* `class`: AddToPlaylist - `example`: *add step to me to the 50 clásicos playlist*\n",
+    "* `class`: RateBook - `example`: *give 6 stars to of mice and men*\n",
+    "* `class`: SearchScreeningEvent - `example` : *find fish story*"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Data can be downloaded from a Google Drive by applying [gdown](https://pypi.org/project/gdown/). In the following code cells the download is invoked only if the corresponding file, does not yet exist at the corresponding location."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "datafolder=\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trainfile=datafolder+\"train.csv\"\n",
+    "testfile=datafolder+\"test.csv\"\n",
+    "validfile=datafolder+\"valid.csv\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, the downloaded .csv-files for training, validation and test are imported into pandas dataframes:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "traindf = pd.read_csv(trainfile)\n",
+    "validdf = pd.read_csv(validfile)\n",
+    "testdf = pd.read_csv(testfile)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>text</th>\n",
+       "      <th>intent</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>listen to westbam alumb allergic on google music</td>\n",
+       "      <td>PlayMusic</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>add step to me to the 50 clásicos playlist</td>\n",
+       "      <td>AddToPlaylist</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>i give this current textbook a rating value of...</td>\n",
+       "      <td>RateBook</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>play the song little robin redbreast</td>\n",
+       "      <td>PlayMusic</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>please add iris dement to my playlist this is ...</td>\n",
+       "      <td>AddToPlaylist</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                text         intent\n",
+       "0   listen to westbam alumb allergic on google music      PlayMusic\n",
+       "1         add step to me to the 50 clásicos playlist  AddToPlaylist\n",
+       "2  i give this current textbook a rating value of...       RateBook\n",
+       "3               play the song little robin redbreast      PlayMusic\n",
+       "4  please add iris dement to my playlist this is ...  AddToPlaylist"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "traindf.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Training data contains 13084 instructions:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(13084, 2)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "traindf.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trainfeatures=traindf.copy()\n",
+    "trainlabels=trainfeatures.pop(\"intent\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "trainfeatures=trainfeatures.values"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Distribution of class-labels in training-data:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#chart = sns.countplot(trainlabels, palette=HAPPY_COLORS_PALETTE)\n",
+    "#plt.title(\"Number of texts per intent\")\n",
+    "#chart\n",
+    "#`chart.set_xticklabels(chart.get_xticklabels(), rotation=30, horizontalalignment='right')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "One-Hot-Encoding of class-labels:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.preprocessing import LabelBinarizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "binarizer=LabelBinarizer()\n",
+    "trainlabels=binarizer.fit_transform(trainlabels.values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(13084, 7)"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trainlabels.shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Preprocess test- and validation data in the same way as it has been done for training-data:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "testfeatures=testdf.copy()\n",
+    "testlabels=testfeatures.pop(\"intent\")\n",
+    "validfeatures=validdf.copy()\n",
+    "validlabels=validfeatures.pop(\"intent\")\n",
+    "\n",
+    "testfeatures=testfeatures.values\n",
+    "validfeatures=validfeatures.values\n",
+    "\n",
+    "testlabels=binarizer.transform(testlabels.values)\n",
+    "validlabels=binarizer.transform(validlabels.values)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "dX8FtlpGJRE6"
+   },
+   "source": [
+    "## Loading models from TensorFlow Hub\n",
+    "\n",
+    "Here you can choose which BERT model you will load from TensorFlow Hub and fine-tune. There are multiple BERT models available.\n",
+    "\n",
+    "  - [BERT-Base](https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3), [Uncased](https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3) and [seven more models](https://tfhub.dev/google/collections/bert/1) with trained weights released by the original BERT authors.\n",
+    "  - [Small BERTs](https://tfhub.dev/google/collections/bert/1) have the same general architecture but fewer and/or smaller Transformer blocks, which lets you explore tradeoffs between speed, size and quality.\n",
+    "  - [ALBERT](https://tfhub.dev/google/collections/albert/1): four different sizes of \"A Lite BERT\" that reduces model size (but not computation time) by sharing parameters between layers.\n",
+    "  - [BERT Experts](https://tfhub.dev/google/collections/experts/bert/1): eight models that all have the BERT-base architecture but offer a choice between different pre-training domains, to align more closely with the target task.\n",
+    "  - [Electra](https://tfhub.dev/google/collections/electra/1) has the same architecture as BERT (in three different sizes), but gets pre-trained as a discriminator in a set-up that resembles a Generative Adversarial Network (GAN).\n",
+    "  - BERT with Talking-Heads Attention and Gated GELU [[base](https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_base/1), [large](https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_large/1)] has two improvements to the core of the Transformer architecture.\n",
+    "\n",
+    "The model documentation on TensorFlow Hub has more details and references to the\n",
+    "research literature. Follow the links above, or click on the [`tfhub.dev`](http://tfhub.dev) URL\n",
+    "printed after the next cell execution.\n",
+    "\n",
+    "The suggestion is to start with a Small BERT (with fewer parameters) since they are faster to fine-tune. If you like a small model but with higher accuracy, ALBERT might be your next option. If you want even better accuracy, choose\n",
+    "one of the classic BERT sizes or their recent refinements like Electra, Talking Heads, or a BERT Expert.\n",
+    "\n",
+    "Aside from the models available below, there are [multiple versions](https://tfhub.dev/google/collections/transformer_encoders_text/1) of the models that are larger and can yield even better accuracy but they are too big to be fine-tuned on a single GPU. You will be able to do that on the [Solve GLUE tasks using BERT on a TPU colab](https://www.tensorflow.org/tutorials/text/solve_glue_tasks_using_bert_on_tpu).\n",
+    "\n",
+    "You'll see in the code below that switching the tfhub.dev URL is enough to try any of these models, because all the differences between them are encapsulated in the SavedModels from TF Hub."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-01-13T03:08:07.421163Z",
+     "iopub.status.busy": "2021-01-13T03:08:07.420022Z",
+     "iopub.status.idle": "2021-01-13T03:08:07.423061Z",
+     "shell.execute_reply": "2021-01-13T03:08:07.423513Z"
+    },
+    "id": "y8_ctG55-uTX"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "BERT model selected           : https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-512_A-8/1\n",
+      "Preprocess model auto-selected: https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2\n"
+     ]
+    }
+   ],
+   "source": [
+    "bert_model_name = 'small_bert/bert_en_uncased_L-8_H-512_A-8' \n",
+    "map_name_to_handle = {\n",
+    "    'bert_en_uncased_L-12_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3',\n",
+    "    'bert_en_cased_L-12_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_cased_L-12_H-768_A-12/3',\n",
+    "    'bert_multi_cased_L-12_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/bert_multi_cased_L-12_H-768_A-12/3',\n",
+    "    'small_bert/bert_en_uncased_L-2_H-128_A-2':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-128_A-2/1',\n",
+    "    'small_bert/bert_en_uncased_L-2_H-256_A-4':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-256_A-4/1',\n",
+    "    'small_bert/bert_en_uncased_L-2_H-512_A-8':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-512_A-8/1',\n",
+    "    'small_bert/bert_en_uncased_L-2_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-768_A-12/1',\n",
+    "    'small_bert/bert_en_uncased_L-4_H-128_A-2':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-128_A-2/1',\n",
+    "    'small_bert/bert_en_uncased_L-4_H-256_A-4':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-256_A-4/1',\n",
+    "    'small_bert/bert_en_uncased_L-4_H-512_A-8':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-512_A-8/1',\n",
+    "    'small_bert/bert_en_uncased_L-4_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-768_A-12/1',\n",
+    "    'small_bert/bert_en_uncased_L-6_H-128_A-2':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-128_A-2/1',\n",
+    "    'small_bert/bert_en_uncased_L-6_H-256_A-4':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-256_A-4/1',\n",
+    "    'small_bert/bert_en_uncased_L-6_H-512_A-8':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-512_A-8/1',\n",
+    "    'small_bert/bert_en_uncased_L-6_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-768_A-12/1',\n",
+    "    'small_bert/bert_en_uncased_L-8_H-128_A-2':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-128_A-2/1',\n",
+    "    'small_bert/bert_en_uncased_L-8_H-256_A-4':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-256_A-4/1',\n",
+    "    'small_bert/bert_en_uncased_L-8_H-512_A-8':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-512_A-8/1',\n",
+    "    'small_bert/bert_en_uncased_L-8_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-768_A-12/1',\n",
+    "    'small_bert/bert_en_uncased_L-10_H-128_A-2':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-128_A-2/1',\n",
+    "    'small_bert/bert_en_uncased_L-10_H-256_A-4':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-256_A-4/1',\n",
+    "    'small_bert/bert_en_uncased_L-10_H-512_A-8':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-512_A-8/1',\n",
+    "    'small_bert/bert_en_uncased_L-10_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-768_A-12/1',\n",
+    "    'small_bert/bert_en_uncased_L-12_H-128_A-2':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-128_A-2/1',\n",
+    "    'small_bert/bert_en_uncased_L-12_H-256_A-4':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-256_A-4/1',\n",
+    "    'small_bert/bert_en_uncased_L-12_H-512_A-8':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-512_A-8/1',\n",
+    "    'small_bert/bert_en_uncased_L-12_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-768_A-12/1',\n",
+    "    'albert_en_base':\n",
+    "        'https://tfhub.dev/tensorflow/albert_en_base/2',\n",
+    "    'electra_small':\n",
+    "        'https://tfhub.dev/google/electra_small/2',\n",
+    "    'electra_base':\n",
+    "        'https://tfhub.dev/google/electra_base/2',\n",
+    "    'experts_pubmed':\n",
+    "        'https://tfhub.dev/google/experts/bert/pubmed/2',\n",
+    "    'experts_wiki_books':\n",
+    "        'https://tfhub.dev/google/experts/bert/wiki_books/2',\n",
+    "    'talking-heads_base':\n",
+    "        'https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_base/1',\n",
+    "}\n",
+    "\n",
+    "map_model_to_preprocess = {\n",
+    "    'bert_en_uncased_L-12_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'bert_en_cased_L-12_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_cased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-2_H-128_A-2':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-2_H-256_A-4':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-2_H-512_A-8':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-2_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-4_H-128_A-2':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-4_H-256_A-4':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-4_H-512_A-8':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-4_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-6_H-128_A-2':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-6_H-256_A-4':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-6_H-512_A-8':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-6_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-8_H-128_A-2':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-8_H-256_A-4':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-8_H-512_A-8':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-8_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-10_H-128_A-2':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-10_H-256_A-4':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-10_H-512_A-8':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-10_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-12_H-128_A-2':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-12_H-256_A-4':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-12_H-512_A-8':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'small_bert/bert_en_uncased_L-12_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'bert_multi_cased_L-12_H-768_A-12':\n",
+    "        'https://tfhub.dev/tensorflow/bert_multi_cased_preprocess/2',\n",
+    "    'albert_en_base':\n",
+    "        'https://tfhub.dev/tensorflow/albert_en_preprocess/2',\n",
+    "    'electra_small':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'electra_base':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'experts_pubmed':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'experts_wiki_books':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "    'talking-heads_base':\n",
+    "        'https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/2',\n",
+    "}\n",
+    "\n",
+    "tfhub_handle_encoder = map_name_to_handle[bert_model_name]\n",
+    "tfhub_handle_preprocess = map_model_to_preprocess[bert_model_name]\n",
+    "\n",
+    "print(f'BERT model selected           : {tfhub_handle_encoder}')\n",
+    "print(f'Preprocess model auto-selected: {tfhub_handle_preprocess}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "7WrcxxTRDdHi"
+   },
+   "source": [
+    "## The preprocessing model\n",
+    "\n",
+    "Text inputs need to be transformed to numeric token ids and arranged in several Tensors before being input to BERT. TensorFlow Hub provides a matching preprocessing model for each of the BERT models discussed above, which implements this transformation using TF ops from the TF.text library. It is not necessary to run pure Python code outside your TensorFlow model to preprocess text.\n",
+    "\n",
+    "The preprocessing model must be the one referenced by the documentation of the BERT model, which you can read at the URL printed above. For BERT models from the drop-down above, the preprocessing model is selected automatically.\n",
+    "\n",
+    "Note: You will load the preprocessing model into a [hub.KerasLayer](https://www.tensorflow.org/hub/api_docs/python/hub/KerasLayer) to compose your fine-tuned model. This is the preferred API to load a TF2-style SavedModel from TF Hub into a Keras model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-01-13T03:08:07.428866Z",
+     "iopub.status.busy": "2021-01-13T03:08:07.427625Z",
+     "iopub.status.idle": "2021-01-13T03:08:10.467605Z",
+     "shell.execute_reply": "2021-01-13T03:08:10.468143Z"
+    },
+    "id": "0SQi-jWd_jzq"
+   },
+   "outputs": [],
+   "source": [
+    "bert_preprocess_model = hub.KerasLayer(tfhub_handle_preprocess)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "x4naBiEE_cZX"
+   },
+   "source": [
+    "Let's try the preprocessing model on some text and see the output:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array(['listen to westbam alumb allergic on google music'], dtype=object)"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "trainfeatures[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-01-13T03:08:10.482448Z",
+     "iopub.status.busy": "2021-01-13T03:08:10.478061Z",
+     "iopub.status.idle": "2021-01-13T03:08:10.652900Z",
+     "shell.execute_reply": "2021-01-13T03:08:10.652248Z"
+    },
+    "id": "r9-zCzJpnuwS"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Keys       : ['input_type_ids', 'input_mask', 'input_word_ids']\n",
+      "Shape      : (1, 128)\n",
+      "Word Ids   : [  101  4952  2000  2225  3676  2213  2632 25438 27395  2006  8224  2189]\n",
+      "Input Mask : [1 1 1 1 1 1 1 1 1 1 1 1]\n",
+      "Type Ids   : [0 0 0 0 0 0 0 0 0 0 0 0]\n"
+     ]
+    }
+   ],
+   "source": [
+    "text_test = trainfeatures[0]\n",
+    "text_preprocessed = bert_preprocess_model(text_test)\n",
+    "\n",
+    "print(f'Keys       : {list(text_preprocessed.keys())}')\n",
+    "print(f'Shape      : {text_preprocessed[\"input_word_ids\"].shape}')\n",
+    "print(f'Word Ids   : {text_preprocessed[\"input_word_ids\"][0, :12]}')\n",
+    "print(f'Input Mask : {text_preprocessed[\"input_mask\"][0, :12]}')\n",
+    "print(f'Type Ids   : {text_preprocessed[\"input_type_ids\"][0, :12]}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "EqL7ihkN_862"
+   },
+   "source": [
+    "As can be seen, there are 3 outputs from the preprocessing that a BERT model would use (`input_words_id`, `input_mask` and `input_type_ids`).\n",
+    "\n",
+    "Some other important points:\n",
+    "- The input is truncated to 128 tokens. The number of tokens can be customized and you can see more details on the [Solve GLUE tasks using BERT on a TPU colab](https://www.tensorflow.org/tutorials/text/solve_glue_tasks_using_bert_on_tpu).\n",
+    "- The `input_type_ids` only have one value (0) because this is a single sentence input. For a multiple sentence input, it would have one number for each input.\n",
+    "\n",
+    "Since this text preprocessor is a TensorFlow model, It can be included in your model directly."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "DKnLPSEmtp9i"
+   },
+   "source": [
+    "## Using the BERT model\n",
+    "\n",
+    "Before putting BERT into an own model, let's take a look at its outputs. You will load it from TF Hub and see the returned values."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-01-13T03:08:10.658519Z",
+     "iopub.status.busy": "2021-01-13T03:08:10.657556Z",
+     "iopub.status.idle": "2021-01-13T03:08:19.674983Z",
+     "shell.execute_reply": "2021-01-13T03:08:19.675465Z"
+    },
+    "id": "tXxYpK8ixL34"
+   },
+   "outputs": [],
+   "source": [
+    "bert_model = hub.KerasLayer(tfhub_handle_encoder)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-01-13T03:08:19.682552Z",
+     "iopub.status.busy": "2021-01-13T03:08:19.681441Z",
+     "iopub.status.idle": "2021-01-13T03:08:20.297383Z",
+     "shell.execute_reply": "2021-01-13T03:08:20.297932Z"
+    },
+    "id": "_OoF9mebuSZc"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loaded BERT: https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-512_A-8/1\n",
+      "Pooled Outputs Shape:(1, 512)\n",
+      "Pooled Outputs Values:[-0.04969434 -0.16525201 -0.99807066 -0.93279284 -0.6145217  -0.22613084\n",
+      " -0.95588505 -0.50678337  0.29122898  0.2631647   0.7982282   0.49405995]\n",
+      "Sequence Outputs Shape:(1, 128, 512)\n",
+      "Sequence Outputs Values:[[-0.1024768   0.22204846  0.59883934 ... -0.25584042  0.61985433\n",
+      "  -0.01822574]\n",
+      " [ 0.4550366  -0.57238305  0.5542101  ... -0.28608793  1.3628979\n",
+      "   0.9131196 ]\n",
+      " [ 0.42473704  0.29045174  0.82693    ...  0.28371704  1.7948036\n",
+      "  -0.36674204]\n",
+      " ...\n",
+      " [-0.46153253  0.02829356  0.51673454 ... -0.15035403  1.4651561\n",
+      "   0.6449582 ]\n",
+      " [ 0.7110826   1.0848484   0.66065294 ...  0.4794111   0.723307\n",
+      "  -0.08312207]\n",
+      " [ 0.35558882 -0.3890488   0.5101847  ...  0.19970936  0.86474574\n",
+      "   0.12227032]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "bert_results = bert_model(text_preprocessed)\n",
+    "\n",
+    "print(f'Loaded BERT: {tfhub_handle_encoder}')\n",
+    "print(f'Pooled Outputs Shape:{bert_results[\"pooled_output\"].shape}')\n",
+    "print(f'Pooled Outputs Values:{bert_results[\"pooled_output\"][0, :12]}')\n",
+    "print(f'Sequence Outputs Shape:{bert_results[\"sequence_output\"].shape}')\n",
+    "print(f'Sequence Outputs Values:{bert_results[\"sequence_output\"][0, :12]}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "sm61jDrezAll"
+   },
+   "source": [
+    "The BERT models return a map with 3 important keys: `pooled_output`, `sequence_output`, `encoder_outputs`:\n",
+    "\n",
+    "- `pooled_output` to represent each input sequence as a whole. The shape is `[batch_size, H]`. You can think of this as an embedding for the entire movie review.\n",
+    "- `sequence_output` represents each input token in the context. The shape is `[batch_size, seq_length, H]`. You can think of this as a contextual embedding for every token in the movie review.\n",
+    "- `encoder_outputs` are the intermediate activations of the `L` Transformer blocks. `outputs[\"encoder_outputs\"][i]` is a Tensor of shape `[batch_size, seq_length, 1024]` with the outputs of the i-th Transformer block, for `0 <= i < L`. The last value of the list is equal to `sequence_output`.\n",
+    "\n",
+    "For the fine-tuning you are going to use the `pooled_output` array."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "pDNKfAXbDnJH"
+   },
+   "source": [
+    "## Define your model\n",
+    "\n",
+    "You will create a very simple fine-tuned model, with the preprocessing model, the selected BERT model, one Dense and a Dropout layer.\n",
+    "\n",
+    "Note: for more information about the base model's input and output you can use just follow the model's url for documentation. Here specifically you don't need to worry about it because the preprocessing model will take care of that for you.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-01-13T03:08:20.306302Z",
+     "iopub.status.busy": "2021-01-13T03:08:20.305016Z",
+     "iopub.status.idle": "2021-01-13T03:08:20.307988Z",
+     "shell.execute_reply": "2021-01-13T03:08:20.307291Z"
+    },
+    "id": "aksj743St9ga"
+   },
+   "outputs": [],
+   "source": [
+    "def build_classifier_model():\n",
+    "  text_input = tf.keras.layers.Input(shape=(), dtype=tf.string, name='text')\n",
+    "  preprocessing_layer = hub.KerasLayer(tfhub_handle_preprocess, name='preprocessing')\n",
+    "  encoder_inputs = preprocessing_layer(text_input)\n",
+    "  encoder = hub.KerasLayer(tfhub_handle_encoder, trainable=True, name='BERT_encoder')\n",
+    "  outputs = encoder(encoder_inputs)\n",
+    "  net = outputs['pooled_output']\n",
+    "  net = tf.keras.layers.Dropout(0.1)(net)\n",
+    "  net = tf.keras.layers.Dense(7, activation=None, name='classifier')(net)\n",
+    "  return tf.keras.Model(text_input, net)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Zs4yhFraBuGQ"
+   },
+   "source": [
+    "Let's check that the model runs with the output of the preprocessing model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-01-13T03:08:20.317706Z",
+     "iopub.status.busy": "2021-01-13T03:08:20.316292Z",
+     "iopub.status.idle": "2021-01-13T03:08:27.279676Z",
+     "shell.execute_reply": "2021-01-13T03:08:27.279042Z"
+    },
+    "id": "mGMF8AZcB2Zy"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tf.Tensor(\n",
+      "[[0.15770487 0.21116826 0.03859028 0.04381749 0.03109054 0.0646299\n",
+      "  0.4529987 ]], shape=(1, 7), dtype=float32)\n"
+     ]
+    }
+   ],
+   "source": [
+    "classifier_model = build_classifier_model()\n",
+    "bert_raw_result = classifier_model(tf.constant(trainfeatures[0]))\n",
+    "print(tf.keras.activations.softmax(bert_raw_result))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "ZTUzNV2JE2G3"
+   },
+   "source": [
+    "The output is meaningless, of course, because the model has not been trained yet.\n",
+    "\n",
+    "Let's take a look at the model's structure."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model: \"model\"\n",
+      "__________________________________________________________________________________________________\n",
+      " Layer (type)                   Output Shape         Param #     Connected to                     \n",
+      "==================================================================================================\n",
+      " text (InputLayer)              [(None,)]            0           []                               \n",
+      "                                                                                                  \n",
+      " preprocessing (KerasLayer)     {'input_type_ids':   0           ['text[0][0]']                   \n",
+      "                                (None, 128),                                                      \n",
+      "                                 'input_mask': (Non                                               \n",
+      "                                e, 128),                                                          \n",
+      "                                 'input_word_ids':                                                \n",
+      "                                (None, 128)}                                                      \n",
+      "                                                                                                  \n",
+      " BERT_encoder (KerasLayer)      {'encoder_outputs':  41373185    ['preprocessing[0][0]',          \n",
+      "                                 [(None, 128, 512),               'preprocessing[0][1]',          \n",
+      "                                 (None, 128, 512),                'preprocessing[0][2]']          \n",
+      "                                 (None, 128, 512),                                                \n",
+      "                                 (None, 128, 512),                                                \n",
+      "                                 (None, 128, 512),                                                \n",
+      "                                 (None, 128, 512),                                                \n",
+      "                                 (None, 128, 512),                                                \n",
+      "                                 (None, 128, 512)],                                               \n",
+      "                                 'default': (None,                                                \n",
+      "                                512),                                                             \n",
+      "                                 'sequence_output':                                               \n",
+      "                                 (None, 128, 512),                                                \n",
+      "                                 'pooled_output': (                                               \n",
+      "                                None, 512)}                                                       \n",
+      "                                                                                                  \n",
+      " dropout (Dropout)              (None, 512)          0           ['BERT_encoder[0][9]']           \n",
+      "                                                                                                  \n",
+      " classifier (Dense)             (None, 7)            3591        ['dropout[0][0]']                \n",
+      "                                                                                                  \n",
+      "==================================================================================================\n",
+      "Total params: 41,376,776\n",
+      "Trainable params: 41,376,775\n",
+      "Non-trainable params: 1\n",
+      "__________________________________________________________________________________________________\n"
+     ]
+    }
+   ],
+   "source": [
+    "classifier_model.summary()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "WbUWoZMwc302"
+   },
+   "source": [
+    "## Model training\n",
+    "\n",
+    "You now have all the pieces to train a model, including the preprocessing module, BERT encoder, data, and classifier."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "WpJ3xcwDT56v"
+   },
+   "source": [
+    "Since this is a non-binary classification problem and the model outputs probabilities, you'll use `losses.CategoricalCrossentropy` loss function.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-01-13T03:08:27.596402Z",
+     "iopub.status.busy": "2021-01-13T03:08:27.595622Z",
+     "iopub.status.idle": "2021-01-13T03:08:27.600436Z",
+     "shell.execute_reply": "2021-01-13T03:08:27.600889Z"
+    },
+    "id": "OWPOZE-L3AgE"
+   },
+   "outputs": [],
+   "source": [
+    "loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True)\n",
+    "metrics = tf.metrics.CategoricalAccuracy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "SqlarlpC_v0g"
+   },
+   "source": [
+    "### Loading the BERT model and training\n",
+    "\n",
+    "Using the `classifier_model` you created earlier, you can compile the model with the loss, metric and optimizer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-01-13T03:08:27.621858Z",
+     "iopub.status.busy": "2021-01-13T03:08:27.621180Z",
+     "iopub.status.idle": "2021-01-13T03:08:27.631397Z",
+     "shell.execute_reply": "2021-01-13T03:08:27.631841Z"
+    },
+    "id": "-7GPDhR98jsD"
+   },
+   "outputs": [],
+   "source": [
+    "epochs=5\n",
+    "optimizer=tf.keras.optimizers.Adam(1e-5)\n",
+    "classifier_model.compile(optimizer=optimizer,\n",
+    "                         loss=loss,\n",
+    "                         metrics=metrics)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "CpBuV5j2cS_b"
+   },
+   "source": [
+    "Note: training time will vary depending on the complexity of the BERT model you have selected."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-01-13T03:08:27.636326Z",
+     "iopub.status.busy": "2021-01-13T03:08:27.635519Z",
+     "iopub.status.idle": "2021-01-13T03:15:50.893395Z",
+     "shell.execute_reply": "2021-01-13T03:15:50.893900Z"
+    },
+    "id": "HtfDFAnN_Neu",
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training model with https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-512_A-8/1\n",
+      "Epoch 1/5\n",
+      " 11/409 [..............................] - ETA: 1:40:36 - loss: 1.9467 - categorical_accuracy: 0.2159"
+     ]
+    }
+   ],
+   "source": [
+    "print(f'Training model with {tfhub_handle_encoder}')\n",
+    "history = classifier_model.fit(x=trainfeatures,y=trainlabels,\n",
+    "                               validation_data=(validfeatures,validlabels),\n",
+    "                               batch_size=32,\n",
+    "                               epochs=epochs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uBthMlTSV8kn"
+   },
+   "source": [
+    "### Evaluate the model\n",
+    "\n",
+    "Let's see how the model performs. Two values will be returned. Loss (a number which represents the error, lower values are better), and accuracy."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-01-13T03:15:50.898967Z",
+     "iopub.status.busy": "2021-01-13T03:15:50.898282Z",
+     "iopub.status.idle": "2021-01-13T03:16:53.613847Z",
+     "shell.execute_reply": "2021-01-13T03:16:53.614285Z"
+    },
+    "id": "slqB-urBV9sP"
+   },
+   "outputs": [],
+   "source": [
+    "loss, accuracy = classifier_model.evaluate(testfeatures,testlabels)\n",
+    "\n",
+    "print(f'Loss: {loss}')\n",
+    "print(f'Accuracy: {accuracy}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uttWpgmSfzq9"
+   },
+   "source": [
+    "### Plot the accuracy and loss over time\n",
+    "\n",
+    "Based on the `History` object returned by `model.fit()`. You can plot the training and validation loss for comparison, as well as the training and validation accuracy:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-01-13T03:16:53.641616Z",
+     "iopub.status.busy": "2021-01-13T03:16:53.638634Z",
+     "iopub.status.idle": "2021-01-13T03:16:53.950276Z",
+     "shell.execute_reply": "2021-01-13T03:16:53.950768Z"
+    },
+    "id": "fiythcODf0xo"
+   },
+   "outputs": [],
+   "source": [
+    "history_dict = history.history\n",
+    "print(history_dict.keys())\n",
+    "\n",
+    "acc = history_dict['categorical_accuracy']\n",
+    "val_acc = history_dict['val_categorical_accuracy']\n",
+    "loss = history_dict['loss']\n",
+    "val_loss = history_dict['val_loss']\n",
+    "\n",
+    "epochs = range(1, len(acc) + 1)\n",
+    "fig = plt.figure(figsize=(10, 8))\n",
+    "fig.tight_layout()\n",
+    "\n",
+    "plt.subplot(2, 1, 1)\n",
+    "# \"bo\" is for \"blue dot\"\n",
+    "plt.plot(epochs, loss, 'r', label='Training loss')\n",
+    "# b is for \"solid blue line\"\n",
+    "plt.plot(epochs, val_loss, 'b', label='Validation loss')\n",
+    "plt.title('Training and validation loss')\n",
+    "plt.grid(True)\n",
+    "# plt.xlabel('Epochs')\n",
+    "plt.ylabel('Loss')\n",
+    "plt.legend()\n",
+    "\n",
+    "plt.subplot(2, 1, 2)\n",
+    "plt.plot(epochs, acc, 'r', label='Training acc')\n",
+    "plt.plot(epochs, val_acc, 'b', label='Validation acc')\n",
+    "plt.title('Training and validation accuracy')\n",
+    "plt.grid(True)\n",
+    "plt.xlabel('Epochs')\n",
+    "plt.ylabel('Accuracy')\n",
+    "plt.legend(loc='lower right')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "WzJZCo-cf-Jf"
+   },
+   "source": [
+    "In this plot, the red lines represents the training loss and accuracy, and the blue lines are the validation loss and accuracy."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "oyTappHTvNCz"
+   },
+   "source": [
+    "Classifying arbitrary instructions:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-01-13T03:17:08.070832Z",
+     "iopub.status.busy": "2021-01-13T03:17:08.068184Z",
+     "iopub.status.idle": "2021-01-13T03:17:08.879352Z",
+     "shell.execute_reply": "2021-01-13T03:17:08.878815Z"
+    },
+    "id": "VBWzH6exlCPS"
+   },
+   "outputs": [],
+   "source": [
+    "def print_my_examples(inputs, results):\n",
+    "  result_for_printing = \\\n",
+    "    [f'input: {inputs[i]:<30} : estimated intent: {results[i]}'\n",
+    "                         for i in range(len(inputs))]\n",
+    "  print(*result_for_printing, sep='\\n')\n",
+    "  print()\n",
+    "\n",
+    "\n",
+    "examples = [\n",
+    "    'play a song from U2',  # this is the same sentence tried earlier\n",
+    "    'Will it rain tomorrow',\n",
+    "    'I like to hear greatist hits from beastie boys',\n",
+    "    'I like to book a table for 3 persons',\n",
+    "    '5 stars for machines like me'\n",
+    "]\n",
+    "\n",
+    "results = tf.nn.softmax(classifier_model(tf.constant(examples)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "binarizer.classes_"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "intents=binarizer.inverse_transform(results.numpy())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2021-01-13T03:17:08.070832Z",
+     "iopub.status.busy": "2021-01-13T03:17:08.068184Z",
+     "iopub.status.idle": "2021-01-13T03:17:08.879352Z",
+     "shell.execute_reply": "2021-01-13T03:17:08.878815Z"
+    },
+    "id": "VBWzH6exlCPS"
+   },
+   "outputs": [],
+   "source": [
+    "print_my_examples(examples, intents)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "collapsed_sections": [],
+   "name": "classify_text_with_bert.ipynb",
+   "toc_visible": true
+  },
+  "kernelspec": {
+   "display_name": "Python 3.8.10 ('caesarainl': venv)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.10"
+  },
+  "toc": {
+   "base_numbering": 1,
+   "nav_menu": {},
+   "number_sections": true,
+   "sideBar": true,
+   "skip_h1_title": false,
+   "title_cell": "Table of Contents",
+   "title_sidebar": "Contents",
+   "toc_cell": false,
+   "toc_position": {},
+   "toc_section_display": true,
+   "toc_window_display": false
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "405f94f3dc67f15d7addffc962b8172d0d4960d3524e541166097ab2d7a328e0"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}

caesar_tensorflow_install.md

@@ -0,0 +1,12 @@
+# Caesar Tensorflow Install 
+# Tensorflow-gpu source versions
+# https://www.tensorflow.org/install/source#gpu
+
+# Use Youtube video
+# MiniConda 
+# https://docs.conda.io/en/main/miniconda.html
+# Cuda Toolkit
+# https://developer.nvidia.com/cuda-11.2.2-download-archive?target_os=Windows&target_arch=x86_64&target_version=10&target_type=exenetwork
+
+# Cuda Deep Neural Network cudnn
+# https://developer.nvidia.com/rdp/cudnn-archive

caesarapis.py

@@ -0,0 +1,26 @@
+import os
+import pyttsx3
+engine=pyttsx3.init('sapi5')
+voices=engine.getProperty('voices')
+engine.setProperty('voice',voices[1].id)
+
+def speak(text,whisper_mode=None):
+    if whisper_mode == 0:
+        engine.say(text)
+        engine.runAndWait()
+
+class CaesarAPIs:
+    def __init__(self) -> None:
+        self.whisper_mode = 0
+    def runapis(self,caesarResponse=None,intent=None,userinput=None):
+        if intent == "whisper_mode" and "on" in userinput:
+            self.whisper_mode = 1
+            speak("I will be quiet now sir",0)
+        elif intent == "whisper_mode" and "off" in userinput:
+            self.whisper_mode = 0
+            speak("Can you hear me now sir",0)
+        #elif 
+        
+
+
+

caesarberthubmodels/bert_to_handle.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:909489abdc059a3f1144c6f69ce064fd0a0932d5d0c4e373f83eb5995831d990
+size 4066

caesarberthubmodels/bert_to_preprocess.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a5c24a7df82f9d8d5b5ec8f94c2b3985e7150bfb30428a3179fd2cc0850c5539
+size 3758

caesarcomplete/berttest.py

@@ -0,0 +1,51 @@
+import tensorflow_hub as hub
+
+BERT_URL = 'https://tfhub.dev/google/bert_cased_L-12_H-768_A-12/1'
+module = hub.Module(BERT_URL)
+
+# Look at the descriptor. This would tell you the model name
+# cat $TFHUB_CACHE_DIR/ecd2596ce849110246602e3d4d81e2d9719cb027.descriptor.txt
+
+# Further look at the assets folder, this has the file `vocab.txt`
+# ls $TFHUB_CACHE_DIR/ecd2596ce849110246602e3d4d81e2d9719cb027/assets
+
+
+import tokenization
+
+def create_tokenizer(vocab_file, do_lower_case=False):
+    return tokenization.FullTokenizer(vocab_file=vocab_file, do_lower_case=do_lower_case)
+    
+tokenizer = create_tokenizer('vocab.txt', do_lower_case=False)
+
+
+def convert_sentence_to_features(sentence, tokenizer, max_seq_len):
+    tokens = ['[CLS]']
+    tokens.extend(tokenizer.tokenize(sentence))
+    if len(tokens) > max_seq_len-1:
+        tokens = tokens[:max_seq_len-1]
+    tokens.append('[SEP]')
+    
+    segment_ids = [0] * len(tokens)
+    input_ids = tokenizer.convert_tokens_to_ids(tokens)
+    input_mask = [1] * len(input_ids)
+
+    #Zero Mask till seq_length
+    zero_mask = [0] * (max_seq_len-len(tokens))
+    input_ids.extend(zero_mask)
+    input_mask.extend(zero_mask)
+    segment_ids.extend(zero_mask)
+    
+    return input_ids, input_mask, segment_ids
+
+def convert_sentences_to_features(sentences, tokenizer, max_seq_len=20):
+    all_input_ids = []
+    all_input_mask = []
+    all_segment_ids = []
+    
+    for sentence in sentences:
+        input_ids, input_mask, segment_ids = convert_sentence_to_features(sentence, tokenizer, max_seq_len)
+        all_input_ids.append(input_ids)
+        all_input_mask.append(input_mask)
+        all_segment_ids.append(segment_ids)
+    
+    return all_input_ids, all_input_mask, all_segment_ids

caesarcomplete/caesar_tensorflow_install.md

@@ -0,0 +1,12 @@
+# Caesar Tensorflow Install 
+# Tensorflow-gpu source versions
+# https://www.tensorflow.org/install/source#gpu
+
+# Use Youtube video
+# MiniConda 
+# https://docs.conda.io/en/main/miniconda.html
+# Cuda Toolkit
+# https://developer.nvidia.com/cuda-11.2.2-download-archive?target_os=Windows&target_arch=x86_64&target_version=10&target_type=exenetwork
+
+# Cuda Deep Neural Network cudnn
+# https://developer.nvidia.com/rdp/cudnn-archive

caesarcomplete/caesarapis.py

@@ -0,0 +1,17 @@
+import os
+class CaesarAPIs:
+    def __init__(self) -> None:
+        self.whisper_mode = 0
+    def runapis(self,caesarResponse=None,intent=None,userinput=None,voiceengine=None):
+        if intent == "whisper_mode" and "on" in userinput:
+            self.whisper_mode = 1
+            voiceengine.say("I will be quiet now sir")
+            voiceengine.runAndWait()
+        elif intent == "whisper_mode" and "off" in userinput:
+            self.whisper_mode = 0
+            voiceengine.say("Can you hear me now sir")
+            voiceengine.runAndWait()
+        
+
+
+

caesarcomplete/caesarnlexamples.py

@@ -0,0 +1,69 @@
+import sys
+import json
+import spacy
+import pickle
+import random
+import tensorflow as tf
+import tensorflow_hub as hub
+import tensorflow_text as text
+from sklearn.preprocessing import LabelBinarizer
+
+def print_my_examples(inputs, results):
+  result_for_printing = \
+    [f'input: {inputs[i]:<30} : estimated intent: {results[i]}'
+                         for i in range(len(inputs))]
+  print(*result_for_printing, sep='\n')
+  print()
+
+
+examples = [
+    'play a song from U2',  # this is the same sentence tried earlier
+    'Will it rain tomorrow',
+    'I like to hear greatist hits from beastie boys',
+    'I like to book a table for 3 persons',
+    '5 stars for machines like me',
+    'play a boogie wit da hoodie',
+    "play Bob's favorite song",
+    "give me a hug",
+    "hello"
+]
+greetings = ["Greeting","smalltalk_greetings_hello"]
+courtesy_greeting = ["CourtesyGreeting"]
+stored_name = "Amari"
+examples = ["hello"]
+#nlp = spacy.load("en_core_web_sm")
+classifier_model = tf.keras.models.load_model('caesarmodel/caesarnl.h5',custom_objects={'KerasLayer':hub.KerasLayer})
+
+# Show the model architecture
+results = tf.nn.softmax(classifier_model(tf.constant(examples)))
+with open("caesarmodel/labelbinarizer.pkl","rb") as f:
+    binarizer = pickle.load(f)
+
+
+intents=binarizer.inverse_transform(results.numpy())
+with open("intentdata/responses.json","r") as f:
+  responses = json.load(f)["responses"]
+
+if intents[0] in greetings:
+  greetresponse = random.choice(responses["Greeting"]).replace("<HUMAN>",stored_name)
+  print(greetresponse)
+  
+
+
+#sentence_intents = dict(zip(examples,intents))
+#print(sentence_intents)
+#print_my_examples(examples, intents)
+
+# TODO AIM - Implement Chatbot Gossip to Caesar
+# 1. Add data to datasets train | valid | test 
+#     a. then clean labels
+# 2. Augment data to provide more potential possibilites
+# 3. Use BERT to match input with the response
+# Command Labels - AddToPlaylist | GetWeather -> API -> user
+# Conversation Labes - Greeting | Goodbye  -> BERTNN: input:"hello" => response:"hi there, I am caesar" -> user
+
+# TODO AIM - Single names of songs artists like "play a boogie" and it will play a boogie's music.
+# 1. Idea one - NER detect the named entities
+# 2. Create new Neural Network that detects that. * Have to determine the relationship between the entites 
+
+

caesarcomplete/data_aggregation.ipynb

@@ -0,0 +1,493 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import json\n",
+    "smalltalkintent = pd.read_csv(\"intentdata/Small_talk_Intent.csv\").rename(columns={\"Utterances\":\"text\",\"Intent\":\"intent\"})\n",
+    "training = pd.read_csv(\"intentdata/train_command.csv\")\n",
+    "df3 = pd.concat([training,smalltalkintent], ignore_index=True)\n",
+    "df3.to_csv(\"intentdata/train.csv\",mode=\"w\",index=False)\n",
+    "# TODO Do NLPAugmentation\n",
+    "#df3 = pd.concat([training,smalltalkintent], ignore_index=True)\n",
+    "#with open(\"intentdata/Intent.json\",\"r\") as f:\n",
+    "#    chatbotXresponseintent = json.load(f)\n",
+    "#chatbotXresponseintent[\"intents\"][0] \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Produce responses\n",
+    "import json \n",
+    "with open(\"intentdata/Intent.json\",\"r\") as f:\n",
+    "    data = json.load(f)\n",
+    "intents = []\n",
+    "for intent in data[\"intents\"]:\n",
+    "    intents.append({\"intent\":intent[\"intent\"],\"responses\":intent[\"responses\"]})\n",
+    "with open(\"intentdata/responses.json\",\"w+\") as f:\n",
+    "    json.dump({\"response\":intents},f)\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"intentdata/responses.json\",\"r\") as f:\n",
+    "  responses = json.load(f)[\"responses\"]\n",
+    "#print(intents[0] in greetings)\n",
+    "#if intents[0] in greetings:\n",
+    "print(responses[\"Greeting\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import pandas as pd \n",
+    "from IPython.display import display\n",
+    "with open(\"intentdata/aug/intent_aug_text.json\",\"r\") as f:\n",
+    "    data = json.load(f)[\"intents\"]\n",
+    "columns_to_concat = []\n",
+    "for i in range(len(data)):\n",
+    "    column1 = pd.DataFrame.from_dict({\"text\":data[i][\"text\"]})\n",
+    "    #print(column1)\n",
+    "    column2 = pd.DataFrame.from_dict({\"intent\":[data[i][\"intent\"] for j in range(len(data[i][\"text\"]))]})\n",
+    "    #print(column2)\n",
+    "    tent_concat= pd.concat([column1,column2],axis=1)\n",
+    "    #print(tent_concat)\n",
+    "    columns_to_concat.append(tent_concat)\n",
+    "intentdf = pd.concat(columns_to_concat,axis=0)\n",
+    "intentdf\n",
+    "df = pd.read_csv(\"intentdata/train.csv\")\n",
+    "newdf = pd.concat([df,intentdf],axis=0)\n",
+    "newdf.to_csv(\"intentdata/train.csv\",mode=\"w\",index=False)\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "data = pd.read_csv(\"intentdata/train.csv\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "data = pd.read_csv(\"intentdata/train_no_half_response.csv\") # Original data is a (2000, 7) DataFrame\n",
+    "data = data.replace(\"smalltalk_agent_acquaintance\",\"CourtesyGreeting\")\n",
+    "data = data.replace(\"smalltalk_agent_age\",\"CurrentHumanQuery\")\n",
+    "data = data.replace(\"smalltalk_agent_annoying\",\"NotTalking2U\")\n",
+    "data = data.replace(\"smalltalk_agent_bad\",\"Swearing\")\n",
+    "data = data.replace(\"smalltalk_agent_boss\",\"CurrentHumanQuery\")\n",
+    "data = data.replace(\"smalltalk_agent_clever\",\"Clever\")\n",
+    "\n",
+    "data = data.replace(\"smalltalk_agent_beautiful\",\"Clever\")\n",
+    "data = data.replace(\"smalltalk_agent_fired\",\"Shutup\")\n",
+    "data = data.replace(\"smalltalk_agent_good\",\"Thanks\")\n",
+    "data = data.replace(\"smalltalk_agent_chatbot\",\"SelfAware\")\n",
+    "data = data.replace(\"smalltalk_agent_real\",\"SelfAware\")\n",
+    "\n",
+    "\n",
+    "data.to_csv(\"intentdata/train.csv\",mode=\"w\",index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO Checks label data balance\n",
+    "import pandas as pd\n",
+    "data = pd.read_csv(\"intentdata/train.csv\") # Original data is a (2000, 7) DataFrame\n",
+    "# data contains 6 feature columns and 1 target column.\n",
+    "\n",
+    "# Separate the design matrix from the target labels.\n",
+    "X = data.iloc[:, :-1]\n",
+    "y = data['intent']\n",
+    "\n",
+    "y.value_counts().sort_index().plot.bar(x='Target Value', y='Number of Occurrences',figsize=(20,20))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "torch.cuda.is_available()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json \n",
+    "import nlpaug.augmenter.word as naw\n",
+    "import nlpaug.flow as naf\n",
+    "print(\"Loading Models...\")\n",
+    "import nltk \n",
+    "nltk.download('wordnet')\n",
+    "nltk.download('omw-1.4')\n",
+    "TOPK=20 #default=100\n",
+    "ACT = 'insert' #\"substitute\"\n",
+    "def tst():\n",
+    "    aug_w2v= naw.WordEmbsAug(\n",
+    "        model_type='glove', model_path='glove/glove.6B.300d.txt',\n",
+    "        action=\"substitute\")\n",
+    "    aug_bert = naw.ContextualWordEmbsAug(\n",
+    "        model_path='distilbert-base-uncased', \n",
+    "        \n",
+    "        action=ACT, top_k=TOPK)\n",
+    "    aug = naf.Sequential([\n",
+    "            aug_bert,aug_w2v\n",
+    "        ])\n",
+    "print(\"Models Loaded.\")\n",
+    "with open(\"intentdata/intent.json\") as f:\n",
+    "    intentwhole = json.load(f)[\"intents\"]\n",
+    "#text = intent[0][\"text\"][3]\n",
+    "for intent in intentwhole:\n",
+    "    for text in intent[\"text\"]:\n",
+    "        augmented_texts = set()\n",
+    "        for i in range(20):\n",
+    "            aug = naw.SynonymAug(aug_src='wordnet',aug_min=1, aug_max=10, aug_p=i/10)\n",
+    "            augmented_text = str(aug.augment(text))\n",
+    "            print(augmented_text)\n",
+    "            #print(augmented_text)\n",
+    "            augmented_texts.add(augmented_text)\n",
+    "        augmented_texts = augmented_texts.union(set(intent[\"text\"]))\n",
+    "        intent[\"text\"] = list(augmented_texts)\n",
+    "    def test():\n",
+    "        if intent[\"intent\"] != \"Jokes\": \n",
+    "            for response in intent[\"responses\"]:\n",
+    "                augmented_responses = set()\n",
+    "                for i in range(20):\n",
+    "                    #aug = naw.SynonymAug(aug_src='wordnet',aug_min=1, aug_max=10, aug_p=i/50,stopwords=[\"<HUMAN>\",\"<HUMAN>,\",\"<HUMAN>!\"])\n",
+    "                    augmented_response = str(aug.augment(response)[0])\n",
+    "                    print(augmented_response)\n",
+    "                    try:\n",
+    "                        augmented_response = augmented_response[:augmented_response.index(\"<\")] + \"<HUMAN\" + augmented_response[augmented_response.index(\">\"):]\n",
+    "                    except ValueError as vex:\n",
+    "                        pass\n",
+    "                    #print(augmented_text)\n",
+    "                    augmented_responses.add(augmented_response)\n",
+    "                augmented_responses = augmented_responses.union(set(intent[\"responses\"]))\n",
+    "                intent[\"responses\"] = list(augmented_responses) \n",
+    "with open(\"intentdata/intent_aug_text_test.json\",\"w+\") as f:\n",
+    "    json.dump({\"intents\":intentwhole},f)\n",
+    "\n",
+    "\n",
+    "print(intentwhole[1][\"responses\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv(\"intentdata/train.csv\")\n",
+    "len(list(pd.unique(df[\"intent\"])))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import json \n",
+    "import pandas as pd\n",
+    "os.listdir(\"new_intent_data\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import spacy\n",
+    "\n",
+    "nlp = spacy.load(\"en_core_web_sm\")\n",
+    "nlp(\"start the fan\").similarity(nlp(\"turn the fan on\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "traindf = pd.read_csv(\"intentdata/train.csv\")\n",
+    "traindf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "intentdf = pd.read_csv(\"new_intent_data/intent_classification.csv\")\n",
+    "traindf = pd.read_csv(\"intentdata/train.csv\")\n",
+    "smart_home_intent = intentdf[[\"text-en\",\"intent-en\"]].rename({\"text-en\":\"text\",\"intent-en\":\"intent\"},axis=1)\n",
+    "newdf = pd.concat([traindf,smart_home_intent],axis=0)\n",
+    "\n",
+    "newdf.to_csv(\"intentdata/train.csv\",mode=\"w\",index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"new_intent_data/Dataset-train_old.txt\") as f:\n",
+    "    textdata = f.readlines()\n",
+    "sent = \"\"\n",
+    "for text in textdata:\n",
+    "    if text == \"\":\n",
+    "        pass\n",
+    "    elif text != \"\":\n",
+    "        if text.count(\",\") == 2:\n",
+    "            #print(text.replace(\",\",\";\",1))\n",
+    "            sent += text.replace(\",\",\";\",1)\n",
+    "        else:\n",
+    "            \n",
+    "            sent += text\n",
+    "print(sent)\n",
+    "with open(\"new_intent_data/Dataset-train.txt\",\"w+\") as f:\n",
+    "    f.write(sent)\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "data = pd.read_csv(\"new_intent_data/Dataset-train.csv\",delimiter=\",\") \n",
+    "data = data.drop(\"Unnamed: 0\",axis=1)\n",
+    "data\n",
+    "data.to_csv(\"new_intent_data/Dataset-train.csv\",index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "data = pd.read_csv(\"new_intent_data/Dataset-train.csv\",delimiter=\",\") # Original data is a (2000, 7) DataFrame\n",
+    "data = data.apply(lambda x: x.replace('\"',''),axis=1)\n",
+    "data.to_csv(\"new_intent_data/Dataset-train.csv\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "data = pd.read_csv(\"new_intent_data/Dataset-train.csv\",delimiter=\"|\") \n",
+    "traindf = pd.read_csv(\"intentdata/train.csv\")\n",
+    "new_data = pd.concat([traindf,data],axis=0)\n",
+    "new_data.to_csv(\"intentdata/train.csv\",index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>text</th>\n",
+       "      <th>intent</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>listen to westbam alumb allergic on google music</td>\n",
+       "      <td>PlayMusic</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>add step to me to the 50 clásicos playlist</td>\n",
+       "      <td>AddToPlaylist</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>i give this current textbook a rating value of...</td>\n",
+       "      <td>RateBook</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>play the song little robin redbreast</td>\n",
+       "      <td>PlayMusic</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>please add iris dement to my playlist this is ...</td>\n",
+       "      <td>AddToPlaylist</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>37306</th>\n",
+       "      <td>what is your date of birth</td>\n",
+       "      <td>how_old_are_you</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>37307</th>\n",
+       "      <td>what year were you born in</td>\n",
+       "      <td>how_old_are_you</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>37308</th>\n",
+       "      <td>what is the year that were you born</td>\n",
+       "      <td>how_old_are_you</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>37309</th>\n",
+       "      <td>how old are you ai</td>\n",
+       "      <td>how_old_are_you</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>37310</th>\n",
+       "      <td>are you 16 years old</td>\n",
+       "      <td>how_old_are_you</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>37311 rows × 2 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                                    text           intent\n",
+       "0       listen to westbam alumb allergic on google music        PlayMusic\n",
+       "1             add step to me to the 50 clásicos playlist    AddToPlaylist\n",
+       "2      i give this current textbook a rating value of...         RateBook\n",
+       "3                   play the song little robin redbreast        PlayMusic\n",
+       "4      please add iris dement to my playlist this is ...    AddToPlaylist\n",
+       "...                                                  ...              ...\n",
+       "37306                         what is your date of birth  how_old_are_you\n",
+       "37307                         what year were you born in  how_old_are_you\n",
+       "37308                what is the year that were you born  how_old_are_you\n",
+       "37309                                 how old are you ai  how_old_are_you\n",
+       "37310                               are you 16 years old  how_old_are_you\n",
+       "\n",
+       "[37311 rows x 2 columns]"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "traindf = pd.read_csv(\"intentdata/train.csv\")\n",
+    "traindf"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3.6.13 ('caesarnlradeon')",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.13"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "bfcbd6a2138b43c88138636b277dc6540d170334c8840148725250eab505a128"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

caesarinfer.py

@@ -0,0 +1,69 @@
+import sys
+import json
+#import spacy
+import pickle
+import random
+import tensorflow as tf
+import tensorflow_hub as hub
+from datetime import datetime
+import tensorflow_text as text
+from sklearn.preprocessing import LabelBinarizer
+
+    
+# TODO AIM - Implement Chatbot Gossip to Caesar
+# 1. Add data to datasets train | valid | test 
+#     a. then clean labels
+# 2. Augment data to provide more potential possibilites
+# 3. Use BERT to match input with the response
+# Command Labels - AddToPlaylist | GetWeather -> API -> user
+# Conversation Labes - Greeting | Goodbye  -> BERTNN: input:"hello" => response:"hi there, I am caesar" -> user
+
+# TODO AIM - Single names of songs artists like "play a boogie" and it will play a boogie's music.
+# 1. Idea one - NER detect the named entities
+# 2. Create new Neural Network that detects that. * Have to determine the relationship between the entites 
+
+
+greetings = ["Greeting","smalltalk_greetings_hello","greeting"]
+courtesy_greeting = ["CourtesyGreeting"]
+
+class CaesarNL:
+  @staticmethod
+  def run(userinput):
+    #if len(sys.argv) == 2:
+    #userinput = [sys.argv[1].lower()]
+    stored_name = "Amari"
+    classifier_model = tf.keras.models.load_model('caesarmodel/caesarnl',custom_objects={'KerasLayer':hub.KerasLayer})
+
+    # Show the model architecture
+    results = tf.nn.softmax(classifier_model(tf.constant(userinput)))
+    print(results.shape)
+    with open("caesarmodel/labelbinarizer.pkl","rb") as f:
+        binarizer = pickle.load(f)
+
+
+    intents=binarizer.inverse_transform(results.numpy())
+    with open("intentdata/responses.json","r") as f:
+      responses = json.load(f)["responses"]
+
+    if intents[0] in greetings:
+      greetresponse = random.choice(responses["Greeting"]).replace("<HUMAN>",stored_name)
+      #print(greetresponse)
+      return greetresponse, intents[0]
+    else:
+      response = f"response to be implemented for text:{userinput}, predicted intent:{intents[0]}"
+      #print(response)
+      return response,intents[0]
+    #elif len(sys.argv) < 2:
+    #response = "What is it, sir?"
+    #print(response)
+    #return response
+      
+
+if __name__ == "__main__":
+  # Takes 17 seconds
+  userinput = ["Hello"]
+  greetresponse,intents = CaesarNL.run(userinput)
+  print(greetresponse,f"intent:{intents}")
+
+
+

caesarmodel/caesarnl/assets/vocab.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:07eced375cec144d27c900241f3e339478dec958f92fddbc551f295c992038a3
+size 231508

caesarmodel/caesarnl/keras_metadata.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4be3f21ee8a1f0852d551bcf7ba86f54d14612589079c7d9079f443e945cbaf
+size 9071

caesarmodel/caesarnl/saved_model.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f0690b8d1f7a6f206358a09b1e983f940132344332858962a723baa31a7e7083
+size 12480367

caesarmodel/caesarnl/variables/variables.data-00000-of-00001

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:859f00425f0b1dd4c873ea0c4311ef243f962d474fa9b5eb8e8eb7fdb1a44484
+size 499589851

caesarmodel/caesarnl/variables/variables.index

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2afa200016405bedd5de9eb7c7dcabb90c22f2dd695bd06b1b2373448a5ed819
+size 32063

caesarmodel/labelbinarizer.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f1b28f7b4ef1ecd72e399caa96f868c2bd24f434a3d1cfe2cbf2fc79582e768
+size 44048

caesarnl.py

@@ -0,0 +1,70 @@
+#import library
+import warnings
+#from gtts import gTTS
+import os
+#from playsound import playsound
+from caesarapis import CaesarAPIs
+import time
+import pyttsx3
+warnings.filterwarnings("ignore")
+import os
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' 
+import speech_recognition as sr
+from caesarinfer import CaesarNL
+# Initialize recognizer class (for recognizing the speech)
+engine=pyttsx3.init('sapi5')
+voices=engine.getProperty('voices')
+engine.setProperty('voice',voices[1].id)
+
+
+def speak(text,whisper_mode=None):
+    if whisper_mode == 0:
+        engine.say(text)
+        engine.runAndWait()
+recognizer = sr.Recognizer()
+
+#def caesartalk(caesarspeech,whisper_mode,filename="example.mp3"):
+#    if whisper_mode == 0:
+#        audio = gTTS(caesarspeech, lang="en", slow=False)
+#       audio.save(filename)
+#        playsound(filename)
+#        time.sleep(1)
+#        if filename in os.listdir():
+#            os.remove(filename)
+# Reading Microphone as source
+# listening the speech and store in audio_text variable
+whisper_state = 1
+caesarapis = CaesarAPIs()
+while True:
+    with sr.Microphone() as source:
+        
+        caesarintro ="How can I help you sir?" 
+        print(caesarintro)
+        #caesartalk(caesarintro,caesarapis.whisper_mode,filename="caesarintro.mp3")
+        speak(caesarintro,caesarapis.whisper_mode)
+        #recognizer
+        recognizer.adjust_for_ambient_noise(source,duration=1)
+        audio_text = recognizer.listen(source)
+        understood = "Understood sir, processing..."
+        print(understood)
+        #caesartalk(understood,caesarapis.whisper_mode,filename="caesar_understood.mp3")
+        speak(understood,caesarapis.whisper_mode)
+        try:
+            # using google speech recognition
+            text = recognizer.recognize_google(audio_text)
+            print(text)
+            print("Caesar processing...")
+            caesarResponse,intent = CaesarNL.run([text])
+            caesarapis.runapis(caesarResponse,intent,text)
+            
+            print(f"User Input: {text}")
+            print(f"Caesar: {caesarResponse}")
+            #caesartalk(caesarResponse,caesarapis.whisper_mode,filename="caesarResponse.mp3")
+            speak(caesarResponse,caesarapis.whisper_mode)
+
+        except Exception as ex:
+            print(type(ex),ex)
+            print("Sorry, I did not get that")
+
+            # whisper_mode
+         

caesarnlexamples.py

@@ -0,0 +1,69 @@
+import sys
+import json
+import spacy
+import pickle
+import random
+import tensorflow as tf
+import tensorflow_hub as hub
+import tensorflow_text as text
+from sklearn.preprocessing import LabelBinarizer
+
+def print_my_examples(inputs, results):
+  result_for_printing = \
+    [f'input: {inputs[i]:<30} : estimated intent: {results[i]}'
+                         for i in range(len(inputs))]
+  print(*result_for_printing, sep='\n')
+  print()
+
+
+examples = [
+    'play a song from U2',  # this is the same sentence tried earlier
+    'Will it rain tomorrow',
+    'I like to hear greatist hits from beastie boys',
+    'I like to book a table for 3 persons',
+    '5 stars for machines like me',
+    'play a boogie wit da hoodie',
+    "play Bob's favorite song",
+    "give me a hug",
+    "hello"
+]
+greetings = ["Greeting","smalltalk_greetings_hello"]
+courtesy_greeting = ["CourtesyGreeting"]
+stored_name = "Amari"
+examples = ["hello"]
+#nlp = spacy.load("en_core_web_sm")
+classifier_model = tf.keras.models.load_model('caesarmodel/caesarnl.h5',custom_objects={'KerasLayer':hub.KerasLayer})
+
+# Show the model architecture
+results = tf.nn.softmax(classifier_model(tf.constant(examples)))
+with open("caesarmodel/labelbinarizer.pkl","rb") as f:
+    binarizer = pickle.load(f)
+
+
+intents=binarizer.inverse_transform(results.numpy())
+with open("intentdata/responses.json","r") as f:
+  responses = json.load(f)["responses"]
+
+if intents[0] in greetings:
+  greetresponse = random.choice(responses["Greeting"]).replace("<HUMAN>",stored_name)
+  print(greetresponse)
+  
+
+
+#sentence_intents = dict(zip(examples,intents))
+#print(sentence_intents)
+#print_my_examples(examples, intents)
+
+# TODO AIM - Implement Chatbot Gossip to Caesar
+# 1. Add data to datasets train | valid | test 
+#     a. then clean labels
+# 2. Augment data to provide more potential possibilites
+# 3. Use BERT to match input with the response
+# Command Labels - AddToPlaylist | GetWeather -> API -> user
+# Conversation Labes - Greeting | Goodbye  -> BERTNN: input:"hello" => response:"hi there, I am caesar" -> user
+
+# TODO AIM - Single names of songs artists like "play a boogie" and it will play a boogie's music.
+# 1. Idea one - NER detect the named entities
+# 2. Create new Neural Network that detects that. * Have to determine the relationship between the entites 
+
+

caesarnlrasp.py

@@ -0,0 +1,70 @@
+#import library
+import os
+import time
+import warnings
+from caesarapis import CaesarAPIs
+import speech_recognition as sr
+warnings.filterwarnings("ignore")
+
+
+
+#os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' 
+# Initialize recognizer class (for recognizing the speech)
+
+
+def speak(text,whisper_mode=0):
+    if whisper_mode == 0:
+        #espeak.synth(text)
+        if "output.mp3" in os.listdir():
+            os.remove("output.mp3")
+        os.system(f'espeak "{text}" --stdout | ffmpeg -i pipe:0 output.mp3')        
+        os.system(f'mplayer -volume 300 output.mp3')   
+        os.system("pkill mplayer")     
+        #raise KeyboardInterrupt
+       #os.system(f'mplayer -af volume=30:1 output.mp3')
+       
+recognizer = sr.Recognizer()
+# Reading Microphone as source
+# listening the speech and store in audio_text variable
+whisper_state = 1
+caesarapis = CaesarAPIs()
+while True:
+    
+        try:
+            caesarintro ="How can I help you sir?" 
+            print(caesarintro)
+            #caesartalk(caesarintro,caesarapis.whisper_mode,filename="caesarintro.mp3")
+            speak(caesarintro,caesarapis.whisper_mode)
+            print("Listening...")
+
+            with sr.Microphone() as source:
+                recognizer.adjust_for_ambient_noise(source,duration=1)
+                audio_text = recognizer.listen(source)
+
+            #print("Billyy")
+            #recognizer
+            understood = "Understood sir, processing..."
+            print(understood)
+            #caesartalk(understood,caesarapis.whisper_mode,filename="caesar_understood.mp3")
+            speak(understood,caesarapis.whisper_mode)
+            # using google speech recognition
+            text = recognizer.recognize_google(audio_text)
+            print("output:",text)
+            print("Caesar processing...")
+            # TODO Send to Azure API
+            if "hello" in text:
+                print("Hola Amari")
+                break
+                #caesarResponse,intent = ("Hola Amari","greeting") 
+                #caesarapis.runapis(caesarResponse,intent,text,speak)
+
+                #print(f"User Input: {text}")
+                #print(f"Caesar: {caesarResponse}")
+                #caesartalk(caesarResponse,caesarapis.whisper_mode,filename="caesarResponse.mp3")
+                #speak(caesarResponse,caesarapis.whisper_mode)
+        except Exception as uex:
+            continue
+
+
+            # whisper_mode
+         

caesartrain.py

@@ -0,0 +1,224 @@
+# -*- coding: utf-8 -*-
+import os
+import json
+#import shutil
+import pickle
+import warnings
+import pandas as pd
+import tensorflow as tf
+import tensorflow_hub as hub
+import tensorflow_text as text
+from pylab import rcParams
+import matplotlib.pyplot as plt
+from sklearn.preprocessing import LabelBinarizer
+warnings.filterwarnings("ignore")
+tf.get_logger().setLevel('ERROR')
+
+class CaesarNLTrain:
+    def train(traindf,validdf,testdf,examples,history_filename = "history.png"):
+        intent_label_output_size = len(pd.unique(traindf["intent"]))
+        trainfeatures=traindf.copy()
+        trainlabels=trainfeatures.pop("intent")
+
+        trainfeatures=trainfeatures.values
+
+
+
+        """One-Hot-Encoding of class-labels:"""
+
+
+
+        binarizer=LabelBinarizer()
+        trainlabels=binarizer.fit_transform(trainlabels.values)
+
+
+        """Preprocess test- and validation data in the same way as it has been done for training-data:"""
+
+        testfeatures=testdf.copy()
+        testlabels=testfeatures.pop("intent")
+        validfeatures=validdf.copy()
+        validlabels=validfeatures.pop("intent")
+
+        testfeatures=testfeatures.values
+        validfeatures=validfeatures.values
+
+        testlabels=binarizer.transform(testlabels.values)
+        validlabels=binarizer.transform(validlabels.values)
+        pickle.dump(binarizer, open('caesarmodel/labelbinarizer.pkl', 'wb'))
+
+        bert_model_name = 'small_bert/bert_en_uncased_L-8_H-512_A-8' 
+        with open("caesarberthubmodels/bert_to_handle.json") as f:
+            map_name_to_handle = json.load(f)
+        with open("caesarberthubmodels/bert_to_preprocess.json") as f:
+            map_model_to_preprocess =  json.load(f)
+
+
+
+        tfhub_handle_encoder = map_name_to_handle[bert_model_name]
+        tfhub_handle_preprocess = map_model_to_preprocess[bert_model_name]
+
+        print(f'BERT model selected           : {tfhub_handle_encoder}')
+        print(f'Preprocess model auto-selected: {tfhub_handle_preprocess}')
+
+
+
+        bert_preprocess_model = hub.KerasLayer(tfhub_handle_preprocess)
+
+
+        trainfeatures[0]
+
+        text_test = trainfeatures[0]
+        text_preprocessed = bert_preprocess_model(text_test)
+
+        bert_model = hub.KerasLayer(tfhub_handle_encoder)
+
+        bert_results = bert_model(text_preprocessed)
+
+
+
+        def build_classifier_model():
+            text_input = tf.keras.layers.Input(shape=(), dtype=tf.string, name='text')
+            preprocessing_layer = hub.KerasLayer(tfhub_handle_preprocess, name='preprocessing')
+            encoder_inputs = preprocessing_layer(text_input)
+            encoder = hub.KerasLayer(tfhub_handle_encoder, trainable=True, name='BERT_encoder')
+            outputs = encoder(encoder_inputs)
+            net = outputs['pooled_output']
+            net = tf.keras.layers.Dropout(0.1)(net)
+            net = tf.keras.layers.Dense(intent_label_output_size, activation=None, name='classifier')(net)
+            return tf.keras.Model(text_input, net)
+
+        """Let's check that the model runs with the output of the preprocessing model."""
+
+        classifier_model = build_classifier_model()
+        bert_raw_result = classifier_model(tf.constant(trainfeatures[0]))
+        print(tf.keras.activations.softmax(bert_raw_result))
+
+        """The output is meaningless, of course, because the model has not been trained yet.
+
+        Let's take a look at the model's structure.
+        """
+
+        classifier_model.summary()
+
+        """## Model training
+
+        You now have all the pieces to train a model, including the preprocessing module, BERT encoder, data, and classifier.
+
+        Since this is a non-binary classification problem and the model outputs probabilities, you'll use `losses.CategoricalCrossentropy` loss function.
+        """
+
+        loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
+        metrics = tf.metrics.CategoricalAccuracy()
+
+        """### Loading the BERT model and training
+
+        Using the `classifier_model` you created earlier, you can compile the model with the loss, metric and optimizer.
+        """
+
+        epochs=5
+        optimizer=tf.keras.optimizers.Adam(1e-5)
+        classifier_model.compile(optimizer=optimizer,
+                                loss=loss,
+                                metrics=metrics)
+
+        """Note: training time will vary depending on the complexity of the BERT model you have selected."""
+
+        print(f'Training model with {tfhub_handle_encoder}')
+        history = classifier_model.fit(x=trainfeatures,y=trainlabels,
+                                    validation_data=(validfeatures,validlabels),
+                                    batch_size=32,
+                                    epochs=epochs)
+        classifier_model.save("caesarmodel/caesarnl.h5")
+
+        """### Evaluate the model
+
+        Let's see how the model performs. Two values will be returned. Loss (a number which represents the error, lower values are better), and accuracy.
+        """
+
+        loss, accuracy = classifier_model.evaluate(testfeatures,testlabels)
+
+        print(f'Loss: {loss}')
+        print(f'Accuracy: {accuracy}')
+
+        """### Plot the accuracy and loss over time
+
+        Based on the `History` object returned by `model.fit()`. You can plot the training and validation loss for comparison, as well as the training and validation accuracy:
+        """
+
+        history_dict = history.history
+        print(history_dict.keys())
+
+        acc = history_dict['categorical_accuracy']
+        val_acc = history_dict['val_categorical_accuracy']
+        loss = history_dict['loss']
+        val_loss = history_dict['val_loss']
+
+        epochs = range(1, len(acc) + 1)
+        fig = plt.figure(figsize=(10, 8))
+        fig.tight_layout()
+
+        plt.subplot(2, 1, 1)
+        # "bo" is for "blue dot"
+        plt.plot(epochs, loss, 'r', label='Training loss')
+        # b is for "solid blue line"
+        plt.plot(epochs, val_loss, 'b', label='Validation loss')
+        plt.title('Training and validation loss')
+        plt.grid(True)
+        # plt.xlabel('Epochs')
+        plt.ylabel('Loss')
+        plt.legend()
+
+        plt.subplot(2, 1, 2)
+        plt.plot(epochs, acc, 'r', label='Training acc')
+        plt.plot(epochs, val_acc, 'b', label='Validation acc')
+        plt.title('Training and validation accuracy')
+        plt.grid(True)
+        plt.xlabel('Epochs')
+        plt.ylabel('Accuracy')
+
+        plt.legend(loc='lower right')
+        plt.savefig(f"caesartrainperformance/{history_filename}")
+
+        """In this plot, the red lines represents the training loss and accuracy, and the blue lines are the validation loss and accuracy.
+
+        Classifying arbitrary instructions:
+        """
+
+        def print_my_examples(inputs, results):
+            result_for_printing = \
+                [f'input: {inputs[i]:<30} : estimated intent: {results[i]}'
+                                    for i in range(len(inputs))]
+            print(*result_for_printing, sep='\n')
+            print()
+
+
+
+
+        results = tf.nn.softmax(classifier_model(tf.constant(examples)))
+
+        binarizer.classes_
+
+        intents=binarizer.inverse_transform(results.numpy())
+
+        print_my_examples(examples, intents)
+if __name__ == "__main__":
+    examples = [
+            'play a song from U2',  # this is the same sentence tried earlier
+            'Will it rain tomorrow',
+            'I like to hear greatist hits from beastie boys',
+            'I like to book a table for 3 persons',
+            '5 stars for machines like me'
+        ]
+    datafolder="intentdata/"
+    trainfile=datafolder+"train.csv"
+    testfile=datafolder+"test.csv"
+    validfile=datafolder+"valid.csv"
+
+    """Next, the downloaded .csv-files for training, validation and test are imported into pandas dataframes:"""
+
+    traindf = pd.read_csv(trainfile)
+    validdf = pd.read_csv(validfile)
+    testdf = pd.read_csv(testfile)
+    
+    CaesarNLTrain.train(traindf,validdf,testdf,examples)
+

data_aggregation.ipynb

@@ -0,0 +1,277 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import json\n",
+    "smalltalkintent = pd.read_csv(\"intentdata/Small_talk_Intent.csv\").rename(columns={\"Utterances\":\"text\",\"Intent\":\"intent\"})\n",
+    "training = pd.read_csv(\"intentdata/train_command.csv\")\n",
+    "df3 = pd.concat([training,smalltalkintent], ignore_index=True)\n",
+    "df3.to_csv(\"intentdata/train.csv\",mode=\"w\",index=False)\n",
+    "# TODO Do NLPAugmentation\n",
+    "#df3 = pd.concat([training,smalltalkintent], ignore_index=True)\n",
+    "#with open(\"intentdata/Intent.json\",\"r\") as f:\n",
+    "#    chatbotXresponseintent = json.load(f)\n",
+    "#chatbotXresponseintent[\"intents\"][0] \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Produce responses\n",
+    "import json \n",
+    "with open(\"intentdata/Intent.json\",\"r\") as f:\n",
+    "    data = json.load(f)\n",
+    "intents = []\n",
+    "for intent in data[\"intents\"]:\n",
+    "    intents.append({\"intent\":intent[\"intent\"],\"responses\":intent[\"responses\"]})\n",
+    "with open(\"intentdata/responses.json\",\"w+\") as f:\n",
+    "    json.dump({\"response\":intents},f)\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open(\"intentdata/responses.json\",\"r\") as f:\n",
+    "  responses = json.load(f)[\"responses\"]\n",
+    "#print(intents[0] in greetings)\n",
+    "#if intents[0] in greetings:\n",
+    "print(responses[\"Greeting\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import pandas as pd \n",
+    "from IPython.display import display\n",
+    "with open(\"intentdata/aug/intent_aug_text.json\",\"r\") as f:\n",
+    "    data = json.load(f)[\"intents\"]\n",
+    "columns_to_concat = []\n",
+    "for i in range(len(data)):\n",
+    "    column1 = pd.DataFrame.from_dict({\"text\":data[i][\"text\"]})\n",
+    "    #print(column1)\n",
+    "    column2 = pd.DataFrame.from_dict({\"intent\":[data[i][\"intent\"] for j in range(len(data[i][\"text\"]))]})\n",
+    "    #print(column2)\n",
+    "    tent_concat= pd.concat([column1,column2],axis=1)\n",
+    "    #print(tent_concat)\n",
+    "    columns_to_concat.append(tent_concat)\n",
+    "intentdf = pd.concat(columns_to_concat,axis=0)\n",
+    "intentdf\n",
+    "df = pd.read_csv(\"intentdata/train.csv\")\n",
+    "newdf = pd.concat([df,intentdf],axis=0)\n",
+    "newdf.to_csv(\"intentdata/train.csv\",mode=\"w\",index=False)\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "data = pd.read_csv(\"intentdata/train.csv\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "data = pd.read_csv(\"intentdata/train_no_half_response.csv\") # Original data is a (2000, 7) DataFrame\n",
+    "data = data.replace(\"smalltalk_agent_acquaintance\",\"CourtesyGreeting\")\n",
+    "data = data.replace(\"smalltalk_agent_age\",\"CurrentHumanQuery\")\n",
+    "data = data.replace(\"smalltalk_agent_annoying\",\"NotTalking2U\")\n",
+    "data = data.replace(\"smalltalk_agent_bad\",\"Swearing\")\n",
+    "data = data.replace(\"smalltalk_agent_boss\",\"CurrentHumanQuery\")\n",
+    "data = data.replace(\"smalltalk_agent_clever\",\"Clever\")\n",
+    "\n",
+    "data = data.replace(\"smalltalk_agent_beautiful\",\"Clever\")\n",
+    "data = data.replace(\"smalltalk_agent_fired\",\"Shutup\")\n",
+    "data = data.replace(\"smalltalk_agent_good\",\"Thanks\")\n",
+    "data = data.replace(\"smalltalk_agent_chatbot\",\"SelfAware\")\n",
+    "data = data.replace(\"smalltalk_agent_real\",\"SelfAware\")\n",
+    "\n",
+    "\n",
+    "data.to_csv(\"intentdata/train.csv\",mode=\"w\",index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# TODO Checks label data balance\n",
+    "import pandas as pd\n",
+    "data = pd.read_csv(\"intentdata/train.csv\") # Original data is a (2000, 7) DataFrame\n",
+    "# data contains 6 feature columns and 1 target column.\n",
+    "\n",
+    "# Separate the design matrix from the target labels.\n",
+    "X = data.iloc[:, :-1]\n",
+    "y = data['intent']\n",
+    "\n",
+    "y.value_counts().sort_index().plot.bar(x='Target Value', y='Number of Occurrences',figsize=(20,20))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "torch.cuda.is_available()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json \n",
+    "import nlpaug.augmenter.word as naw\n",
+    "import nlpaug.flow as naf\n",
+    "print(\"Loading Models...\")\n",
+    "TOPK=20 #default=100\n",
+    "ACT = 'insert' #\"substitute\"\n",
+    "aug_w2v= naw.WordEmbsAug(\n",
+    "    model_type='glove', model_path='glove/glove.6B.300d.txt',\n",
+    "    action=\"substitute\")\n",
+    "aug_bert = naw.ContextualWordEmbsAug(\n",
+    "    model_path='distilbert-base-uncased', \n",
+    "    \n",
+    "    action=ACT, top_k=TOPK)\n",
+    "aug = naf.Sequential([\n",
+    "        aug_bert,aug_w2v\n",
+    "    ])\n",
+    "print(\"Models Loaded.\")\n",
+    "with open(\"intentdata/intent.json\") as f:\n",
+    "    intentwhole = json.load(f)[\"intents\"]\n",
+    "#text = intent[0][\"text\"][3]\n",
+    "for intent in intentwhole:\n",
+    "    for text in intent[\"text\"]:\n",
+    "        augmented_texts = set()\n",
+    "        for i in range(20):\n",
+    "            #aug = naw.SynonymAug(aug_src='wordnet',aug_min=1, aug_max=10, aug_p=i/10)\n",
+    "            augmented_text = str(aug.augment(text)[0])\n",
+    "            print(augmented_text)\n",
+    "            #print(augmented_text)\n",
+    "            augmented_texts.add(augmented_text)\n",
+    "        augmented_texts = augmented_texts.union(set(intent[\"text\"]))\n",
+    "        intent[\"text\"] = list(augmented_texts)\n",
+    "    def test():\n",
+    "        if intent[\"intent\"] != \"Jokes\": \n",
+    "            for response in intent[\"responses\"]:\n",
+    "                augmented_responses = set()\n",
+    "                for i in range(20):\n",
+    "                    #aug = naw.SynonymAug(aug_src='wordnet',aug_min=1, aug_max=10, aug_p=i/50,stopwords=[\"<HUMAN>\",\"<HUMAN>,\",\"<HUMAN>!\"])\n",
+    "                    augmented_response = str(aug.augment(response)[0])\n",
+    "                    print(augmented_response)\n",
+    "                    try:\n",
+    "                        augmented_response = augmented_response[:augmented_response.index(\"<\")] + \"<HUMAN\" + augmented_response[augmented_response.index(\">\"):]\n",
+    "                    except ValueError as vex:\n",
+    "                        pass\n",
+    "                    #print(augmented_text)\n",
+    "                    augmented_responses.add(augmented_response)\n",
+    "                augmented_responses = augmented_responses.union(set(intent[\"responses\"]))\n",
+    "                intent[\"responses\"] = list(augmented_responses) \n",
+    "with open(\"intentdata/intent_aug_text_test.json\",\"w+\") as f:\n",
+    "    json.dump({\"intents\":intentwhole},f)\n",
+    "\n",
+    "\n",
+    "print(intentwhole[1][\"responses\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv(\"intentdata/train.csv\")\n",
+    "len(list(pd.unique(df[\"intent\"])))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['20000-Utterances-Training-dataset-for-chatbots-virtual-assistant-Bitext-sample',\n",
+       " 'AskUbuntu Corpus.json',\n",
+       " 'Bitext_Sample_Customer_Service_Training_Dataset',\n",
+       " 'Chatbot Corpus.json',\n",
+       " 'Dataset-train.csv',\n",
+       " 'intent-corpus-basic.json',\n",
+       " 'intent-corpus-enrich-limit-20.json',\n",
+       " 'intents.json',\n",
+       " 'intent_classification.csv',\n",
+       " 'music_intent_entities.json',\n",
+       " 'restaurant_intent_entities.json',\n",
+       " 'Web App Corpus.json']"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import json \n",
+    "import pandas as pd\n",
+    "os.listdir(\"new_intent_data\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.6 (main, Nov 14 2022, 16:10:14) [GCC 11.3.0]"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "916dbcbb3f70747c44a77c7bcd40155683ae19c65e1c03b4aa3499c5328201f1"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

glove/glove.6B.300d.txt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91125602f730fea7ca768736c6f442e668b49db095682bf2aad375db061c21ed
+size 1037962819

intentdata/Intent.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa7a26bc52c78129d9d8ee1b0869296dea221cee8ac9917eddfe3cf85ff314f0
+size 69909

intentdata/Small_talk_Intent.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21f77e92d68efbba58ef7f8d5e83c024ee424914e03e5263c117c6c4d4d57c02
+size 112938

intentdata/aug/intent_aug.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e44a8f5bf7d0ef5461c2d5c456d41fb95a5e89243f89906db6b3bc4a887c769
+size 956737

intentdata/aug/intent_aug_text.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18fd098e8140e5634af282308e60c20d56532e6f93d2c53792ef08454ea67876
+size 166271

intentdata/intent_aug_text_test.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e68f0837f43d08b5c816c18c0b4f7b06663eacf657db29d390de22f67fd6c30b
+size 215508

intentdata/responses.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e3ac745ff4639e958da57bf4a95a89ffd881841eebf9cd586c9fd011f61a08a
+size 43596

intentdata/test.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14238327adbc98959c324884d1690c06504ed1c751199c68489542f3fb6fbb86
+size 43112

intentdata/train.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7bd871b9af6266016ad9ec8b68fa411c21774a647113f2c2da9aad752dc6f078
+size 1017949

intentdata/train_prev/train copy.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7bd871b9af6266016ad9ec8b68fa411c21774a647113f2c2da9aad752dc6f078
+size 1017949

intentdata/train_prev/train copy_recent.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33922ccc5fb200af7cd21a3679ed57e2a04db3bda5f79deeeb96020e7dc27b5c
+size 1837180

intentdata/train_prev/train_command.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:af3855f2000fa8ce9a9f2e81a7a92395e07b1695f9353f16765f4c7fb08a613c
+size 798951

intentdata/train_prev/train_no_half_response.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:327d2145ccb4d62c85853339abcc17f1b66636135c3e101083b8577e9e174da4
+size 927503

intentdata/valid.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21201144b9832b8c6e0715331f8d3379ae49194311abfb43bb6df02abe61d0f9
+size 43306

main.py

@@ -0,0 +1,55 @@
+import asyncio
+import os
+import uvicorn
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from caesarinfer import CaesarNL
+app = FastAPI()
+
+CURRENT_DIR = os.path.realpath(__file__).replace(f"/main.py","")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # can alter with time
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class CaesarAINLModel(BaseModel):
+    caesarapi: str
+@app.get("/")
+def caesarhome():
+    return "Caeser: How can I help you sir?"
+
+@app.get("/caesarapi")
+def caesarapiget():
+    return "Caeser: Hello sir, this is the CaesarAIAPI"
+    
+@app.post("/caesarapi")
+def caesarapi(caesarapijson: CaesarAINLModel):
+    try:
+        caesarapijson = dict(caesarapijson)
+        
+        print("Caesar Processing...")
+        caesarResponse,intents = CaesarNL.run([caesarapijson["caesarapi"]])
+        print("Caesar Processed.")
+        print(caesarResponse,"intent:",intents)
+
+        return {"caesarmessage":{"caesarResponse":caesarResponse,"intent":intents}}
+
+    except Exception as ex:
+        return {"error":f"{type(ex)}-{ex}"}
+
+
+
+
+
+async def main():
+    config = uvicorn.Config("main:app", port=7860, log_level="info",host="0.0.0.0",reload=True)
+    server = uvicorn.Server(config)
+    await server.serve()
+
+if __name__ == "__main__":
+    asyncio.run(main())