Caesar ShowCase Start

.gitattributes

@@ -0,0 +1,3 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+*.h5 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,26 @@
+node_modules
+*.log
+.next
+app
+notionsrenv
+package-lock.json
+Caesar Old
+build
+CaesarAudioWAVs
+*.wav
+Miscallenouse Translate
+Miscallenouse 
+caesaraienv
+caesaraineuralnetenv
+caesarsummarize.exe
+test.exe
+caesarai
+dist
+glove.6B.300d_should_be_here.txt
+glove.6B.300d.txt
+*.csv
+*.json
+*.txt
+*.xlsx
+*.pyc
+caesarmodel

CaesarAIAPP/.expo/README.md

@@ -0,0 +1,15 @@
+> Why do I have a folder named ".expo" in my project?
+
+The ".expo" folder is created when an Expo project is started using "expo start" command.
+
+> What do the files contain?
+
+- "devices.json": contains information about devices that have recently opened this project. This is used to populate the "Development sessions" list in your development builds.
+- "packager-info.json": contains port numbers and process PIDs that are used to serve the application to the mobile device/simulator.
+- "settings.json": contains the server configuration that is used to serve the application manifest.
+
+> Should I commit the ".expo" folder?
+
+No, you should not share the ".expo" folder. It does not contain any information that is relevant for other developers working on the project, it is specific to your machine.
+
+Upon project creation, the ".expo" folder is already added to your ".gitignore" file.

CaesarAIAPP/App copy.js

@@ -0,0 +1,162 @@
+import * as React from 'react';
+import { Text, View, StyleSheet, Button,TouchableHighlight,ActivityIndicator,Alert,Image} from 'react-native';
+import { Audio } from 'expo-av';
+import axios from 'axios';
+import { Feather } from '@expo/vector-icons';
+import { EvilIcons } from '@expo/vector-icons';
+import { FontAwesome } from '@expo/vector-icons';
+
+export default function App() {
+  const [recording, setRecording] = React.useState();
+  const [recognition,setRecognition] = React.useState();
+  const [caesarson,setCaesarOn] = React.useState(false);
+  const [recognizing,setRecognizing] = React.useState(false);
+  async function turncaesaron(){
+    setRecognizing(true)
+    const response = await axios.get("https://palondomus-caesarai.hf.space")
+    
+    if (response.data === "Welcome to CaesarAI's API's and CaesarAINL."){
+      console.log(response.data)
+      setCaesarOn(true)
+      setRecognizing(false)
+    }
+
+  }
+  const toCapitalize = (str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  };
+  
+
+  async function startRecording() {
+    try {
+      if (caesarson === true){
+      console.log('Requesting permissions..');
+      await Audio.requestPermissionsAsync();
+      await Audio.setAudioModeAsync({
+        allowsRecordingIOS: true,
+        playsInSilentModeIOS: true,
+      }); 
+      console.log('Starting recording..');
+      const recording = new Audio.Recording();
+      await recording.prepareToRecordAsync(Audio.RECORDING_OPTIONS_PRESET_HIGH_QUALITY);
+      await recording.startAsync(); 
+      setRecording(recording);
+      console.log('Recording started');}
+      else{
+        Alert.alert("Turn CaesarON")
+      }
+    } catch (err) {
+      console.error('Failed to start recording', err);
+    }
+  }
+
+  async function stopRecording() {
+      // utitlity function to convert BLOB to BASE64
+  const blobToBase64 = (blob) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(blob);
+    return new Promise((resolve) => {
+      reader.onloadend = () => {
+        resolve(reader.result);
+      };
+    });
+  };
+    console.log('Stopping recording..');
+    setRecording(undefined);
+    await recording.stopAndUnloadAsync();
+    const uri = recording.getURI(); 
+    const blob = await new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+      xhr.onload = function () {
+        resolve(xhr.response);
+      };
+      xhr.onerror = function (e) {
+        reject(new TypeError("Network request failed"));
+      };
+      xhr.responseType = "blob";
+      xhr.open("GET", uri, true);
+      xhr.send(null);
+    });
+    const audioBase64 = await blobToBase64(blob);
+    setRecognizing(true)
+    const response = await axios.post("https://palondomus-caesarai.hf.space/caesarsr",{"audio_data":audioBase64})
+    //console.log(response.data)
+    setRecognition(response.data.message)
+    setRecognizing(false)
+    //console.log('Recording stopped and stored at', uri);
+    blob.close()
+    
+  }
+
+  return (
+   
+    <View
+    style={[
+      styles.container,
+      {
+        // Try setting `flexDirection` to `"row"`.
+        flexDirection: 'column',
+      },
+    ]}>
+    <View style={{position:"absolute",width:100,height:100}} >
+      <Image style={{position:"absolute",width:"100%",height:"100%",top:30}} source={require("./CaesarAILogo.png")}></Image>
+    </View>
+    <View style={{flex: 1}} > 
+      
+      <View style={{display:"flex",flexDirection:"row",justifyContent:"flex-end",alignItems:"flex-end"}}>
+      
+      <TouchableHighlight style={{position:"relative",top:30,right:20}} onPress={turncaesaron}>
+          <Feather name="power"  size={34} style={{color:caesarson === false ? "red":"blue"}}/>
+          </TouchableHighlight>
+        <TouchableHighlight style={{position:"relative",top:30,right:0}} >
+            <EvilIcons name="navicon" size={44} color="red" />
+        </TouchableHighlight>
+      </View>
+    </View>
+
+    <View style={{flex: 2}} >
+      <View style={{display:"flex",flexDirection:"row",justifyContent:"center",alignItems:"center"}}>
+        <View style={{position:"relative",top:30}}>
+          { recognition !== undefined &&
+          <Text style={{fontSize:30}}>{toCapitalize(recognition+".")}</Text>
+          }
+          
+          {recognizing === true && <ActivityIndicator style={{marginTop:30}} size={55} /> }
+        </View>
+      </View>
+     
+    </View>
+    <View style={{flex: 3}} >
+      <View style={{display:"flex",flexDirection:"row",justifyContent:"center",alignItems:"center"}}>
+        <TouchableHighlight style={{position:"relative",top:70}} onPress={recording ? stopRecording : startRecording}>
+              <FontAwesome name="microphone" size={94} style={{color:recording ? 'blue' : 'black'}} />
+        </TouchableHighlight>
+        </View>
+    </View>
+  </View>
+
+  );
+}
+/*      <Button
+        title={recording ? 'Stop Recording' : 'Start Recording'}
+        onPress={recording ? stopRecording : startRecording}
+      /> */
+
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    padding: 20,
+  },
+});
+/*
+    <View style={{"flex":""}}>
+      <Text>{recognition}</Text>
+      <TouchableHighlight onPress={turncaesaron}>
+      <Feather name="power"  size={24} style={{color:caesarson === false ? "red":"blue"}}/>
+      </TouchableHighlight>
+      <Button
+        title={recording ? 'Stop Recording' : 'Start Recording'}
+        onPress={recording ? stopRecording : startRecording}
+      />
+    </View> */

CaesarAIAPP/Recording-Audio-in-React-Native-Expo

@@ -0,0 +1 @@
+Subproject commit 1cfc6b5ae2ab37cf217e0eed524894594d4ade37

CaesarAIAPP/backend/CaesarAIAPI

@@ -0,0 +1 @@
+Subproject commit 1f039900883be91f728313490cfe16e7165d8723

CaesarAIAPP/frontend

@@ -0,0 +1 @@
+Subproject commit 13ac3048649c9a7a8520a4612e62f780ec04d403

CaesarAIAPP/frontend-main/.gitignore

@@ -0,0 +1,14 @@
+node_modules/
+.expo/
+dist/
+npm-debug.*
+*.jks
+*.p8
+*.p12
+*.key
+*.mobileprovision
+*.orig.*
+web-build/
+
+# macOS
+.DS_Store

CaesarAIAPP/frontend-main/App.js

@@ -0,0 +1,20 @@
+import { StatusBar } from 'expo-status-bar';
+import { StyleSheet, Text, View } from 'react-native';
+
+export default function App() {
+  return (
+    <View style={styles.container}>
+      <Text>Open up App.js to start working on your app!</Text>
+      <StatusBar style="auto" />
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: '#fff',
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+});

CaesarAIAPP/frontend-main/babel.config.js

@@ -0,0 +1,6 @@
+module.exports = function(api) {
+  api.cache(true);
+  return {
+    presets: ['babel-preset-expo'],
+  };
+};

CaesarAIAPP/translateWithWhisper

@@ -0,0 +1 @@
+Subproject commit 03798a52483e9a322390df7c307f880e17c7e9c7

CaesarAIGPT/test.ipynb

@@ -0,0 +1,647 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## makemore: part 5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn.functional as F\n",
+    "import matplotlib.pyplot as plt # for making figures\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "32033\n",
+      "15\n",
+      "['emma', 'olivia', 'ava', 'isabella', 'sophia', 'charlotte', 'mia', 'amelia']\n"
+     ]
+    }
+   ],
+   "source": [
+    "# read in all the words\n",
+    "words = open('names.txt', 'r').read().splitlines()\n",
+    "print(len(words))\n",
+    "print(max(len(w) for w in words))\n",
+    "print(words[:8])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g', 8: 'h', 9: 'i', 10: 'j', 11: 'k', 12: 'l', 13: 'm', 14: 'n', 15: 'o', 16: 'p', 17: 'q', 18: 'r', 19: 's', 20: 't', 21: 'u', 22: 'v', 23: 'w', 24: 'x', 25: 'y', 26: 'z', 0: '.'}\n",
+      "27\n"
+     ]
+    }
+   ],
+   "source": [
+    "# build the vocabulary of characters and mappings to/from integers\n",
+    "chars = sorted(list(set(''.join(words))))\n",
+    "stoi = {s:i+1 for i,s in enumerate(chars)}\n",
+    "stoi['.'] = 0\n",
+    "itos = {i:s for s,i in stoi.items()}\n",
+    "vocab_size = len(itos)\n",
+    "print(itos)\n",
+    "print(vocab_size)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# shuffle up the words\n",
+    "import random\n",
+    "random.seed(42)\n",
+    "random.shuffle(words)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([182625, 8]) torch.Size([182625])\n",
+      "torch.Size([22655, 8]) torch.Size([22655])\n",
+      "torch.Size([22866, 8]) torch.Size([22866])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# build the dataset\n",
+    "block_size = 8 # context length: how many characters do we take to predict the next one?\n",
+    "\n",
+    "def build_dataset(words):  \n",
+    "  X, Y = [], []\n",
+    "  \n",
+    "  for w in words:\n",
+    "    context = [0] * block_size\n",
+    "    for ch in w + '.':\n",
+    "      ix = stoi[ch]\n",
+    "      X.append(context)\n",
+    "      Y.append(ix)\n",
+    "      context = context[1:] + [ix] # crop and append\n",
+    "\n",
+    "  X = torch.tensor(X)\n",
+    "  Y = torch.tensor(Y)\n",
+    "  print(X.shape, Y.shape)\n",
+    "  return X, Y\n",
+    "\n",
+    "n1 = int(0.8*len(words))\n",
+    "n2 = int(0.9*len(words))\n",
+    "Xtr,  Ytr  = build_dataset(words[:n1])     # 80%\n",
+    "Xdev, Ydev = build_dataset(words[n1:n2])   # 10%\n",
+    "Xte,  Yte  = build_dataset(words[n2:])     # 10%"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "........ --> y\n",
+      ".......y --> u\n",
+      "......yu --> h\n",
+      ".....yuh --> e\n",
+      "....yuhe --> n\n",
+      "...yuhen --> g\n",
+      "..yuheng --> .\n",
+      "........ --> d\n",
+      ".......d --> i\n",
+      "......di --> o\n",
+      ".....dio --> n\n",
+      "....dion --> d\n",
+      "...diond --> r\n",
+      "..diondr --> e\n",
+      ".diondre --> .\n",
+      "........ --> x\n",
+      ".......x --> a\n",
+      "......xa --> v\n",
+      ".....xav --> i\n",
+      "....xavi --> e\n"
+     ]
+    }
+   ],
+   "source": [
+    "for x,y in zip(Xtr[:20], Ytr[:20]):\n",
+    "  print(''.join(itos[ix.item()] for ix in x), '-->', itos[y.item()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Near copy paste of the layers we have developed in Part 3\n",
+    "\n",
+    "# -----------------------------------------------------------------------------------------------\n",
+    "class Linear:\n",
+    "  \n",
+    "  def __init__(self, fan_in, fan_out, bias=True):\n",
+    "    self.weight = torch.randn((fan_in, fan_out)) / fan_in**0.5 # note: kaiming init\n",
+    "    self.bias = torch.zeros(fan_out) if bias else None\n",
+    "  \n",
+    "  def __call__(self, x):\n",
+    "    self.out = x @ self.weight\n",
+    "    if self.bias is not None:\n",
+    "      self.out += self.bias\n",
+    "    return self.out\n",
+    "  \n",
+    "  def parameters(self):\n",
+    "    return [self.weight] + ([] if self.bias is None else [self.bias])\n",
+    "\n",
+    "# -----------------------------------------------------------------------------------------------\n",
+    "class BatchNorm1d:\n",
+    "  \n",
+    "  def __init__(self, dim, eps=1e-5, momentum=0.1):\n",
+    "    self.eps = eps\n",
+    "    self.momentum = momentum\n",
+    "    self.training = True\n",
+    "    # parameters (trained with backprop)\n",
+    "    self.gamma = torch.ones(dim)\n",
+    "    self.beta = torch.zeros(dim)\n",
+    "    # buffers (trained with a running 'momentum update')\n",
+    "    self.running_mean = torch.zeros(dim)\n",
+    "    self.running_var = torch.ones(dim)\n",
+    "  \n",
+    "  def __call__(self, x):\n",
+    "    # calculate the forward pass\n",
+    "    if self.training:\n",
+    "      if x.ndim == 2:\n",
+    "        dim = 0\n",
+    "      elif x.ndim == 3:\n",
+    "        dim = (0,1)\n",
+    "      xmean = x.mean(dim, keepdim=True) # batch mean\n",
+    "      xvar = x.var(dim, keepdim=True) # batch variance\n",
+    "    else:\n",
+    "      xmean = self.running_mean\n",
+    "      xvar = self.running_var\n",
+    "    xhat = (x - xmean) / torch.sqrt(xvar + self.eps) # normalize to unit variance\n",
+    "    self.out = self.gamma * xhat + self.beta\n",
+    "    # update the buffers\n",
+    "    if self.training:\n",
+    "      with torch.no_grad():\n",
+    "        self.running_mean = (1 - self.momentum) * self.running_mean + self.momentum * xmean\n",
+    "        self.running_var = (1 - self.momentum) * self.running_var + self.momentum * xvar\n",
+    "    return self.out\n",
+    "  \n",
+    "  def parameters(self):\n",
+    "    return [self.gamma, self.beta]\n",
+    "\n",
+    "# -----------------------------------------------------------------------------------------------\n",
+    "class Tanh:\n",
+    "  def __call__(self, x):\n",
+    "    self.out = torch.tanh(x)\n",
+    "    return self.out\n",
+    "  def parameters(self):\n",
+    "    return []\n",
+    "\n",
+    "# -----------------------------------------------------------------------------------------------\n",
+    "class Embedding:\n",
+    "  \n",
+    "  def __init__(self, num_embeddings, embedding_dim):\n",
+    "    self.weight = torch.randn((num_embeddings, embedding_dim))\n",
+    "    \n",
+    "  def __call__(self, IX):\n",
+    "    self.out = self.weight[IX]\n",
+    "    return self.out\n",
+    "  \n",
+    "  def parameters(self):\n",
+    "    return [self.weight]\n",
+    "\n",
+    "# -----------------------------------------------------------------------------------------------\n",
+    "class FlattenConsecutive:\n",
+    "  \n",
+    "  def __init__(self, n):\n",
+    "    self.n = n\n",
+    "    \n",
+    "  def __call__(self, x):\n",
+    "    B, T, C = x.shape\n",
+    "    x = x.view(B, T//self.n, C*self.n)\n",
+    "    if x.shape[1] == 1:\n",
+    "      x = x.squeeze(1)\n",
+    "    self.out = x\n",
+    "    return self.out\n",
+    "  \n",
+    "  def parameters(self):\n",
+    "    return []\n",
+    "\n",
+    "# -----------------------------------------------------------------------------------------------\n",
+    "class Sequential:\n",
+    "  \n",
+    "  def __init__(self, layers):\n",
+    "    self.layers = layers\n",
+    "  \n",
+    "  def __call__(self, x):\n",
+    "    for layer in self.layers:\n",
+    "      x = layer(x)\n",
+    "    self.out = x\n",
+    "    return self.out\n",
+    "  \n",
+    "  def parameters(self):\n",
+    "    # get parameters of all layers and stretch them out into one list\n",
+    "    return [p for layer in self.layers for p in layer.parameters()]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "torch.manual_seed(42); # seed rng for reproducibility"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "76579\n"
+     ]
+    }
+   ],
+   "source": [
+    "# original network\n",
+    "# n_embd = 10 # the dimensionality of the character embedding vectors\n",
+    "# n_hidden = 300 # the number of neurons in the hidden layer of the MLP\n",
+    "# model = Sequential([\n",
+    "#   Embedding(vocab_size, n_embd),\n",
+    "#   FlattenConsecutive(8), Linear(n_embd * 8, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(),\n",
+    "#   Linear(n_hidden, vocab_size),\n",
+    "# ])\n",
+    "\n",
+    "# hierarchical network\n",
+    "n_embd = 24 # the dimensionality of the character embedding vectors\n",
+    "n_hidden = 128 # the number of neurons in the hidden layer of the MLP\n",
+    "model = Sequential([\n",
+    "  Embedding(vocab_size, n_embd),\n",
+    "  FlattenConsecutive(2), Linear(n_embd * 2, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(),\n",
+    "  FlattenConsecutive(2), Linear(n_hidden*2, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(),\n",
+    "  FlattenConsecutive(2), Linear(n_hidden*2, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(),\n",
+    "  Linear(n_hidden, vocab_size),\n",
+    "])\n",
+    "\n",
+    "# parameter init\n",
+    "with torch.no_grad():\n",
+    "  model.layers[-1].weight *= 0.1 # last layer make less confident\n",
+    "\n",
+    "parameters = model.parameters()\n",
+    "print(sum(p.nelement() for p in parameters)) # number of parameters in total\n",
+    "for p in parameters:\n",
+    "  p.requires_grad = True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "      0/ 200000: 3.3167\n",
+      "  10000/ 200000: 2.0576\n",
+      "  20000/ 200000: 2.0723\n",
+      "  30000/ 200000: 2.5134\n",
+      "  40000/ 200000: 2.1476\n",
+      "  50000/ 200000: 1.7836\n",
+      "  60000/ 200000: 2.2592\n",
+      "  70000/ 200000: 1.9331\n",
+      "  80000/ 200000: 1.6875\n",
+      "  90000/ 200000: 2.0395\n",
+      " 100000/ 200000: 1.7736\n",
+      " 110000/ 200000: 1.9570\n",
+      " 120000/ 200000: 1.7465\n",
+      " 130000/ 200000: 1.8126\n",
+      " 140000/ 200000: 1.7406\n",
+      " 150000/ 200000: 1.7466\n",
+      " 160000/ 200000: 1.8806\n",
+      " 170000/ 200000: 1.6266\n",
+      " 180000/ 200000: 1.6476\n",
+      " 190000/ 200000: 1.8555\n"
+     ]
+    }
+   ],
+   "source": [
+    "# same optimization as last time\n",
+    "max_steps = 200000\n",
+    "batch_size = 32\n",
+    "lossi = []\n",
+    "\n",
+    "for i in range(max_steps):\n",
+    "  \n",
+    "  # minibatch construct\n",
+    "  ix = torch.randint(0, Xtr.shape[0], (batch_size,))\n",
+    "  Xb, Yb = Xtr[ix], Ytr[ix] # batch X,Y\n",
+    "  \n",
+    "  # forward pass\n",
+    "  logits = model(Xb)\n",
+    "  loss = F.cross_entropy(logits, Yb) # loss function\n",
+    "  \n",
+    "  # backward pass\n",
+    "  for p in parameters:\n",
+    "    p.grad = None\n",
+    "  loss.backward()\n",
+    "  \n",
+    "  # update: simple SGD\n",
+    "  lr = 0.1 if i < 150000 else 0.01 # step learning rate decay\n",
+    "  for p in parameters:\n",
+    "    p.data += -lr * p.grad\n",
+    "\n",
+    "  # track stats\n",
+    "  if i % 10000 == 0: # print every once in a while\n",
+    "    print(f'{i:7d}/{max_steps:7d}: {loss.item():.4f}')\n",
+    "  lossi.append(loss.log10().item())\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7fb5a03e3b50>]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(torch.tensor(lossi).view(-1, 1000).mean(1))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# put layers into eval mode (needed for batchnorm especially)\n",
+    "for layer in model.layers:\n",
+    "  layer.training = False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train 1.7690284252166748\n",
+      "val 1.9936515092849731\n"
+     ]
+    }
+   ],
+   "source": [
+    "# evaluate the loss\n",
+    "@torch.no_grad() # this decorator disables gradient tracking inside pytorch\n",
+    "def split_loss(split):\n",
+    "  x,y = {\n",
+    "    'train': (Xtr, Ytr),\n",
+    "    'val': (Xdev, Ydev),\n",
+    "    'test': (Xte, Yte),\n",
+    "  }[split]\n",
+    "  logits = model(x)\n",
+    "  loss = F.cross_entropy(logits, y)\n",
+    "  print(split, loss.item())\n",
+    "\n",
+    "split_loss('train')\n",
+    "split_loss('val')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### performance log\n",
+    "\n",
+    "- original (3 character context + 200 hidden neurons, 12K params): train 2.058, val 2.105\n",
+    "- context: 3 -> 8 (22K params): train 1.918, val 2.027\n",
+    "- flat -> hierarchical (22K params): train 1.941, val 2.029\n",
+    "- fix bug in batchnorm: train 1.912, val 2.022\n",
+    "- scale up the network: n_embd 24, n_hidden 128 (76K params): train 1.769, val 1.993\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "arlij.\n",
+      "chetta.\n",
+      "heago.\n",
+      "rocklei.\n",
+      "hendrix.\n",
+      "jamylie.\n",
+      "broxin.\n",
+      "denish.\n",
+      "anslibt.\n",
+      "marianah.\n",
+      "astavia.\n",
+      "annayve.\n",
+      "aniah.\n",
+      "jayce.\n",
+      "nodiel.\n",
+      "remita.\n",
+      "niyelle.\n",
+      "jaylene.\n",
+      "aiyan.\n",
+      "aubreana.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# sample from the model\n",
+    "for _ in range(20):\n",
+    "    \n",
+    "    out = []\n",
+    "    context = [0] * block_size # initialize with all ...\n",
+    "    while True:\n",
+    "      # forward pass the neural net\n",
+    "      logits = model(torch.tensor([context]))\n",
+    "      probs = F.softmax(logits, dim=1)\n",
+    "      # sample from the distribution\n",
+    "      ix = torch.multinomial(probs, num_samples=1).item()\n",
+    "      # shift the context window and track the samples\n",
+    "      context = context[1:] + [ix]\n",
+    "      out.append(ix)\n",
+    "      # if we sample the special '.' token, break\n",
+    "      if ix == 0:\n",
+    "        break\n",
+    "    \n",
+    "    print(''.join(itos[i] for i in out)) # decode and print the generated word"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Next time:\n",
+    "Why convolutions? Brief preview/hint"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "........ --> d\n",
+      ".......d --> i\n",
+      "......di --> o\n",
+      ".....dio --> n\n",
+      "....dion --> d\n",
+      "...diond --> r\n",
+      "..diondr --> e\n",
+      ".diondre --> .\n"
+     ]
+    }
+   ],
+   "source": [
+    "for x,y in zip(Xtr[7:15], Ytr[7:15]):\n",
+    "  print(''.join(itos[ix.item()] for ix in x), '-->', itos[y.item()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([1, 27])"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# forward a single example:\n",
+    "logits = model(Xtr[[7]])\n",
+    "logits.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([8, 27])"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# forward all of them\n",
+    "logits = torch.zeros(8, 27)\n",
+    "for i in range(8):\n",
+    "  logits[i] = model(Xtr[[7+i]])\n",
+    "logits.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# convolution is a \"for loop\"\n",
+    "# allows us to forward Linear layers efficiently over space"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "caesaranalysis",
+   "language": "python",
+   "name": "caesaranalysis"
+  },
+  "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.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

CaesarAINL/Procfile

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

CaesarAINL/amari@172.20.10.197/caesarReminder.py

@@ -0,0 +1,52 @@
+import os
+import json
+import time
+import requests
+from datetime import datetime, timedelta
+class CaesarReminder:
+    @staticmethod
+    def reminder():
+        if "CaesarReminders" in os.listdir():
+            if "caesarreminders.json" in os.listdir("CaesarReminders"):
+                with open("CaesarReminders/caesarreminders.json","r") as f:
+                    reminders = json.load(f)
+                message = ""    
+                for reminder in reminders["reminders"]:
+                    message += f"{reminder['subject']}"
+                    message += f"<br>"
+                    message += f"{reminder['message']}"
+                    message += f"<br>"
+                    message += f"Reminder: {datetime.fromisoformat(reminder['timestep']).strftime('%m/%d/%Y, %H:%M:%S')}\n"
+                    message += "<br>"
+                    message += "<br>"
+                sendjson = {"raspsendemail":{"email":reminders["email"],"message":message,"subject":"Caesar Reminders"}}
+                response = requests.post("https://revisionbank-email.onrender.com/raspsendemail",json=sendjson)
+                print(response.text)
+
+
+            elif "caesarreminders.json" not in os.listdir("CaesarReminders"):
+                sendjson = {"raspsendemail":{"email":"amari.lawal@gmail.com","message":"No Reminders Scheduled","subject":"Caesar Reminders"}}
+                response = requests.post("https://revisionbank-email.onrender.com/raspsendemail",json=sendjson)
+                print(response.text)
+                
+
+
+            # send email saying reminder
+        elif "CaesarReminders" not in os.listdir():
+            sendjson = {"raspsendemail":{"email":"amari.lawal@gmail.com","message":"No Reminders Scheduled","subject":"Caesar Reminders"}}
+            response = requests.post("https://revisionbank-email.onrender.com/raspsendemail",json=sendjson)
+            print(response.text)
+            # Send email saying No reminders
+
+
+
+
+if __name__ == "__main__":
+    constant = 60 *60 
+    duration = 48 * constant # hours
+    
+    #print(datetime.now().isoformat())
+    while True:
+        CaesarReminder.reminder()
+        time.sleep(duration)
+    #pass

CaesarAINL/amari@172.20.10.197/caesarapis/caesarReminder.py

@@ -0,0 +1,52 @@
+import os
+import json
+import time
+import requests
+from datetime import datetime, timedelta
+class CaesarReminder:
+    @staticmethod
+    def reminder():
+        if "CaesarReminders" in os.listdir():
+            if "caesarreminders.json" in os.listdir("CaesarReminders"):
+                with open("CaesarReminders/caesarreminders.json","r") as f:
+                    reminders = json.load(f)
+                message = ""    
+                for reminder in reminders["reminders"]:
+                    message += f"{reminder['subject']}"
+                    message += f"<br>"
+                    message += f"{reminder['message']}"
+                    message += f"<br>"
+                    message += f"Reminder: {datetime.fromisoformat(reminder['timestep']).strftime('%m/%d/%Y, %H:%M:%S')}\n"
+                    message += "<br>"
+                    message += "<br>"
+                sendjson = {"raspsendemail":{"email":reminders["email"],"message":message,"subject":"Caesar Reminders"}}
+                response = requests.post("https://revisionbank-email.onrender.com/raspsendemail",json=sendjson)
+                print(response.text)
+
+
+            elif "caesarreminders.json" not in os.listdir("CaesarReminders"):
+                sendjson = {"raspsendemail":{"email":"amari.lawal@gmail.com","message":"No Reminders Scheduled","subject":"Caesar Reminders"}}
+                response = requests.post("https://revisionbank-email.onrender.com/raspsendemail",json=sendjson)
+                print(response.text)
+                
+
+
+            # send email saying reminder
+        elif "CaesarReminders" not in os.listdir():
+            sendjson = {"raspsendemail":{"email":"amari.lawal@gmail.com","message":"No Reminders Scheduled","subject":"Caesar Reminders"}}
+            response = requests.post("https://revisionbank-email.onrender.com/raspsendemail",json=sendjson)
+            print(response.text)
+            # Send email saying No reminders
+
+
+
+
+if __name__ == "__main__":
+    constant = 60 *60 
+    duration = 48 * constant # hours
+    
+    #print(datetime.now().isoformat())
+    while True:
+        CaesarReminder.reminder()
+        time.sleep(duration)
+    #pass

CaesarAINL/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) # 

CaesarAINL/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)
+

CaesarAINL/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
+}

CaesarAINL/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

CaesarAINL/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 
+        
+
+
+

CaesarAINL/caesarapis/caesarReminder.py

@@ -0,0 +1,52 @@
+import os
+import json
+import time
+import requests
+from datetime import datetime, timedelta
+class CaesarReminder:
+    @staticmethod
+    def reminder():
+        if "CaesarReminders" in os.listdir():
+            if "caesarreminders.json" in os.listdir("CaesarReminders"):
+                with open("CaesarReminders/caesarreminders.json","r") as f:
+                    reminders = json.load(f)
+                message = ""    
+                for reminder in reminders["reminders"]:
+                    message += "{}".format(reminder['subject'])
+                    message += "<br>"
+                    message += "{}".format(reminder['message'])
+                    message += "<br>"
+                    message += "Reminder: {}\n".format(datetime.fromisoformat(reminder['timestep']).strftime('%m/%d/%Y, %H:%M:%S'))
+                    message += "<br>"
+                    message += "<br>"
+                sendjson = {"raspsendemail":{"email":reminders["email"],"message":message,"subject":"Caesar Reminders"}}
+                response = requests.post("https://revisionbank-email.onrender.com/raspsendemail",json=sendjson)
+                print(response.text)
+
+
+            elif "caesarreminders.json" not in os.listdir("CaesarReminders"):
+                sendjson = {"raspsendemail":{"email":"amari.lawal@gmail.com","message":"No Reminders Scheduled","subject":"Caesar Reminders"}}
+                response = requests.post("https://revisionbank-email.onrender.com/raspsendemail",json=sendjson)
+                print(response.text)
+                
+
+
+            # send email saying reminder
+        elif "CaesarReminders" not in os.listdir():
+            sendjson = {"raspsendemail":{"email":"amari.lawal@gmail.com","message":"No Reminders Scheduled","subject":"Caesar Reminders"}}
+            response = requests.post("https://revisionbank-email.onrender.com/raspsendemail",json=sendjson)
+            print(response.text)
+            # Send email saying No reminders
+
+
+
+
+if __name__ == "__main__":
+    constant = 60 *60 
+    duration = 48 * constant # hours
+    
+    #print(datetime.now().isoformat())
+    while True:
+        CaesarReminder.reminder()
+        time.sleep(duration)
+    #pass

CaesarAINL/caesarbackground.md

@@ -0,0 +1,5 @@
+# CaesarBackground
+# start caesarbackground - sudo nohup /home/amari/Desktop/CaesarAI/CaesarAINL/caesarapis/caesarReminder.py > caesarReminder.out &
+
+# kill nohup processes - pkill -f caesarReminder.py
+# list nohup processes -  ps ax | grep caesarReminder.py

CaesarAINL/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

CaesarAINL/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

CaesarAINL/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()
+        
+
+
+

CaesarAINL/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 
+
+

CaesarAINL/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
+}

CaesarAINL/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}")
+
+
+

CaesarAINL/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
+         

CaesarAINL/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 
+
+

CaesarAINL/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
+         

CaesarAINL/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)
+

CaesarAINL/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.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
+}

CaesarAINL/runcaesarnl.bat

@@ -0,0 +1 @@
+"C:\Users\amari\.conda\envs\caesarinfer\python.exe" "D:\CaesarAI\CaesarAINL\caesarnl.py"