{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":52950,"databundleVersionId":5973250,"sourceType":"competition"}],"dockerImageVersionId":30587,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"!pip install mediapipe","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2023-12-12T12:55:40.062982Z","iopub.execute_input":"2023-12-12T12:55:40.064054Z","iopub.status.idle":"2023-12-12T12:55:55.652865Z","shell.execute_reply.started":"2023-12-12T12:55:40.064007Z","shell.execute_reply":"2023-12-12T12:55:55.651137Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import os\nimport shutil\nimport numpy as np\nimport pandas as pd\nimport pyarrow.parquet as pq\nimport tensorflow as tf\nimport json\nimport mediapipe\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport random\n\nfrom skimage.transform import resize\nfrom mediapipe.framework.formats import landmark_pb2\nfrom tensorflow import keras\nfrom tensorflow.keras import layers\nfrom tqdm.notebook import tqdm\nfrom matplotlib import animation, rc","metadata":{"_kg_hide-input":false,"execution":{"iopub.status.busy":"2023-12-12T12:55:55.655959Z","iopub.execute_input":"2023-12-12T12:55:55.656513Z","iopub.status.idle":"2023-12-12T12:56:13.452971Z","shell.execute_reply.started":"2023-12-12T12:55:55.656462Z","shell.execute_reply":"2023-12-12T12:56:13.451681Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"dataset_df = pd.read_csv('/kaggle/input/asl-fingerspelling/train.csv')\nprint(\"Full train dataset shape is {}\".format(dataset_df.shape))","metadata":{"execution":{"iopub.status.busy":"2023-12-12T12:56:13.454491Z","iopub.execute_input":"2023-12-12T12:56:13.455279Z","iopub.status.idle":"2023-12-12T12:56:13.666822Z","shell.execute_reply.started":"2023-12-12T12:56:13.455242Z","shell.execute_reply":"2023-12-12T12:56:13.665361Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Fetch sequence_id, file_id, phrase from first row\nsequence_id, file_id, phrase = dataset_df.iloc[1][['sequence_id', 'file_id', 'phrase']]\nprint(f\"sequence_id: {sequence_id}, file_id: {file_id}, phrase: {phrase}\")","metadata":{"execution":{"iopub.status.busy":"2023-12-12T12:56:13.670001Z","iopub.execute_input":"2023-12-12T12:56:13.670422Z","iopub.status.idle":"2023-12-12T12:56:13.694814Z","shell.execute_reply.started":"2023-12-12T12:56:13.670389Z","shell.execute_reply":"2023-12-12T12:56:13.693627Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Fetch data from parquet file\nsample_sequence_df = pq.read_table(f\"/kaggle/input/asl-fingerspelling/train_landmarks/{str(file_id)}.parquet\",\n filters=[[('sequence_id', '=', sequence_id)],]).to_pandas()\nprint(\"Full sequence dataset shape is {}\".format(sample_sequence_df.shape))","metadata":{"execution":{"iopub.status.busy":"2023-12-12T12:56:13.696756Z","iopub.execute_input":"2023-12-12T12:56:13.697192Z","iopub.status.idle":"2023-12-12T12:56:18.18456Z","shell.execute_reply.started":"2023-12-12T12:56:13.69716Z","shell.execute_reply":"2023-12-12T12:56:18.183338Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Pose coordinates for hand movement.\nLPOSE = [13, 15, 17, 19, 21]\nRPOSE = [14, 16, 18, 20, 22]\nPOSE = LPOSE + RPOSE","metadata":{"execution":{"iopub.status.busy":"2023-12-12T12:56:18.186128Z","iopub.execute_input":"2023-12-12T12:56:18.18648Z","iopub.status.idle":"2023-12-12T12:56:18.191896Z","shell.execute_reply.started":"2023-12-12T12:56:18.186449Z","shell.execute_reply":"2023-12-12T12:56:18.190956Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X = [f'x_right_hand_{i}' for i in range(21)] + [f'x_left_hand_{i}' for i in range(21)] + [f'x_pose_{i}' for i in POSE]\nY = [f'y_right_hand_{i}' for i in range(21)] + [f'y_left_hand_{i}' for i in range(21)] + [f'y_pose_{i}' for i in POSE]\nZ = [f'z_right_hand_{i}' for i in range(21)] + [f'z_left_hand_{i}' for i in range(21)] + [f'z_pose_{i}' for i in POSE]","metadata":{"execution":{"iopub.status.busy":"2023-12-12T12:56:18.193809Z","iopub.execute_input":"2023-12-12T12:56:18.194556Z","iopub.status.idle":"2023-12-12T12:56:18.205749Z","shell.execute_reply.started":"2023-12-12T12:56:18.194521Z","shell.execute_reply":"2023-12-12T12:56:18.204251Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"FEATURE_COLUMNS = X + Y + Z","metadata":{"execution":{"iopub.status.busy":"2023-12-12T12:56:18.207663Z","iopub.execute_input":"2023-12-12T12:56:18.2084Z","iopub.status.idle":"2023-12-12T12:56:18.218377Z","shell.execute_reply.started":"2023-12-12T12:56:18.208337Z","shell.execute_reply":"2023-12-12T12:56:18.217374Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_IDX = [i for i, col in enumerate(FEATURE_COLUMNS) if \"x_\" in col]\nY_IDX = [i for i, col in enumerate(FEATURE_COLUMNS) if \"y_\" in col]\nZ_IDX = [i for i, col in enumerate(FEATURE_COLUMNS) if \"z_\" in col]\n\nRHAND_IDX = [i for i, col in enumerate(FEATURE_COLUMNS) if \"right\" in col]\nLHAND_IDX = [i for i, col in enumerate(FEATURE_COLUMNS) if \"left\" in col]\nRPOSE_IDX = [i for i, col in enumerate(FEATURE_COLUMNS) if \"pose\" in col and int(col[-2:]) in RPOSE]\nLPOSE_IDX = [i for i, col in enumerate(FEATURE_COLUMNS) if \"pose\" in col and int(col[-2:]) in LPOSE]","metadata":{"execution":{"iopub.status.busy":"2023-12-12T12:56:18.21957Z","iopub.execute_input":"2023-12-12T12:56:18.22042Z","iopub.status.idle":"2023-12-12T12:56:18.235973Z","shell.execute_reply.started":"2023-12-12T12:56:18.220382Z","shell.execute_reply":"2023-12-12T12:56:18.234242Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Set length of frames to 128\nFRAME_LEN = 128\n\n# Create directory to store the new data\nif not os.path.isdir(\"preprocessed\"):\n os.mkdir(\"preprocessed\")\nelse:\n shutil.rmtree(\"preprocessed\")\n os.mkdir(\"preprocessed\")\n\n# Loop through each file_id\nfor file_id in tqdm(dataset_df.file_id.unique()):\n # Parquet file name\n pq_file = f\"/kaggle/input/asl-fingerspelling/train_landmarks/{file_id}.parquet\"\n # Filter train.csv and fetch entries only for the relevant file_id\n file_df = dataset_df.loc[dataset_df[\"file_id\"] == file_id]\n # Fetch the parquet file\n parquet_df = pq.read_table(f\"/kaggle/input/asl-fingerspelling/train_landmarks/{str(file_id)}.parquet\",\n columns=['sequence_id'] + FEATURE_COLUMNS).to_pandas()\n # File name for the updated data\n tf_file = f\"preprocessed/{file_id}.tfrecord\"\n parquet_numpy = parquet_df.to_numpy()\n # Initialize the pointer to write the output of \n # each `for loop` below as a sequence into the file.\n with tf.io.TFRecordWriter(tf_file) as file_writer:\n # Loop through each sequence in file.\n for seq_id, phrase in zip(file_df.sequence_id, file_df.phrase):\n # Fetch sequence data\n frames = parquet_numpy[parquet_df.index == seq_id]\n \n # Calculate the number of NaN values in each hand landmark\n r_nonan = np.sum(np.sum(np.isnan(frames[:, RHAND_IDX]), axis = 1) == 0)\n l_nonan = np.sum(np.sum(np.isnan(frames[:, LHAND_IDX]), axis = 1) == 0)\n no_nan = max(r_nonan, l_nonan)\n \n if 2*len(phrase) lnans:\n hand = lhand\n pose = lpose\n \n hand_x = hand[:, 0*(len(LHAND_IDX)//3) : 1*(len(LHAND_IDX)//3)]\n hand_y = hand[:, 1*(len(LHAND_IDX)//3) : 2*(len(LHAND_IDX)//3)]\n hand_z = hand[:, 2*(len(LHAND_IDX)//3) : 3*(len(LHAND_IDX)//3)]\n hand = tf.concat([1-hand_x, hand_y, hand_z], axis=1)\n \n pose_x = pose[:, 0*(len(LPOSE_IDX)//3) : 1*(len(LPOSE_IDX)//3)]\n pose_y = pose[:, 1*(len(LPOSE_IDX)//3) : 2*(len(LPOSE_IDX)//3)]\n pose_z = pose[:, 2*(len(LPOSE_IDX)//3) : 3*(len(LPOSE_IDX)//3)]\n pose = tf.concat([1-pose_x, pose_y, pose_z], axis=1)\n else:\n hand = rhand\n pose = rpose\n \n hand_x = hand[:, 0*(len(LHAND_IDX)//3) : 1*(len(LHAND_IDX)//3)]\n hand_y = hand[:, 1*(len(LHAND_IDX)//3) : 2*(len(LHAND_IDX)//3)]\n hand_z = hand[:, 2*(len(LHAND_IDX)//3) : 3*(len(LHAND_IDX)//3)]\n hand = tf.concat([hand_x[..., tf.newaxis], hand_y[..., tf.newaxis], hand_z[..., tf.newaxis]], axis=-1)\n \n mean = tf.math.reduce_mean(hand, axis=1)[:, tf.newaxis, :]\n std = tf.math.reduce_std(hand, axis=1)[:, tf.newaxis, :]\n hand = (hand - mean) / std\n\n pose_x = pose[:, 0*(len(LPOSE_IDX)//3) : 1*(len(LPOSE_IDX)//3)]\n pose_y = pose[:, 1*(len(LPOSE_IDX)//3) : 2*(len(LPOSE_IDX)//3)]\n pose_z = pose[:, 2*(len(LPOSE_IDX)//3) : 3*(len(LPOSE_IDX)//3)]\n pose = tf.concat([pose_x[..., tf.newaxis], pose_y[..., tf.newaxis], pose_z[..., tf.newaxis]], axis=-1)\n \n x = tf.concat([hand, pose], axis=1)\n x = resize_pad(x)\n \n x = tf.where(tf.math.is_nan(x), tf.zeros_like(x), x)\n x = tf.reshape(x, (FRAME_LEN, len(LHAND_IDX) + len(LPOSE_IDX)))\n return x","metadata":{"execution":{"iopub.status.busy":"2023-12-12T13:10:08.498939Z","iopub.execute_input":"2023-12-12T13:10:08.499412Z","iopub.status.idle":"2023-12-12T13:10:08.538303Z","shell.execute_reply.started":"2023-12-12T13:10:08.499377Z","shell.execute_reply":"2023-12-12T13:10:08.535883Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def decode_fn(record_bytes):\n schema = {COL: tf.io.VarLenFeature(dtype=tf.float32) for COL in FEATURE_COLUMNS}\n schema[\"phrase\"] = tf.io.FixedLenFeature([], dtype=tf.string)\n features = tf.io.parse_single_example(record_bytes, schema)\n phrase = features[\"phrase\"]\n landmarks = ([tf.sparse.to_dense(features[COL]) for COL in FEATURE_COLUMNS])\n # Transpose to maintain the original shape of landmarks data.\n landmarks = tf.transpose(landmarks)\n \n return landmarks, phrase","metadata":{"execution":{"iopub.status.busy":"2023-12-12T13:10:08.545789Z","iopub.execute_input":"2023-12-12T13:10:08.547135Z","iopub.status.idle":"2023-12-12T13:10:08.560253Z","shell.execute_reply.started":"2023-12-12T13:10:08.54709Z","shell.execute_reply":"2023-12-12T13:10:08.557554Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"table = tf.lookup.StaticHashTable(\n initializer=tf.lookup.KeyValueTensorInitializer(\n keys=list(char_to_num.keys()),\n values=list(char_to_num.values()),\n ),\n default_value=tf.constant(-1),\n name=\"class_weight\"\n)\n\ndef convert_fn(landmarks, phrase):\n # Add start and end pointers to phrase.\n phrase = start_token + phrase + end_token\n phrase = tf.strings.bytes_split(phrase)\n phrase = table.lookup(phrase)\n # Vectorize and add padding.\n phrase = tf.pad(phrase, paddings=[[0, 64 - tf.shape(phrase)[0]]], mode = 'CONSTANT',\n constant_values = pad_token_idx)\n # Apply pre_process function to the landmarks.\n return pre_process(landmarks), phrase","metadata":{"execution":{"iopub.status.busy":"2023-12-12T13:10:08.562794Z","iopub.execute_input":"2023-12-12T13:10:08.56336Z","iopub.status.idle":"2023-12-12T13:10:08.857447Z","shell.execute_reply.started":"2023-12-12T13:10:08.563316Z","shell.execute_reply":"2023-12-12T13:10:08.856236Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"batch_size = 64\ntrain_len = int(0.8 * len(tf_records))\n\ntrain_ds = tf.data.TFRecordDataset(tf_records[:train_len]).map(decode_fn).map(convert_fn).batch(batch_size).prefetch(buffer_size=tf.data.AUTOTUNE).cache()\nvalid_ds = tf.data.TFRecordDataset(tf_records[train_len:]).map(decode_fn).map(convert_fn).batch(batch_size).prefetch(buffer_size=tf.data.AUTOTUNE).cache()","metadata":{"execution":{"iopub.status.busy":"2023-12-12T13:10:08.860231Z","iopub.execute_input":"2023-12-12T13:10:08.860676Z","iopub.status.idle":"2023-12-12T13:10:11.773375Z","shell.execute_reply.started":"2023-12-12T13:10:08.860637Z","shell.execute_reply":"2023-12-12T13:10:11.771839Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class TokenEmbedding(layers.Layer):\n def __init__(self, num_vocab=1000, maxlen=100, num_hid=64):\n super().__init__()\n self.emb = tf.keras.layers.Embedding(num_vocab, num_hid)\n self.pos_emb = layers.Embedding(input_dim=maxlen, output_dim=num_hid)\n\n def call(self, x):\n maxlen = tf.shape(x)[-1]\n x = self.emb(x)\n positions = tf.range(start=0, limit=maxlen, delta=1)\n positions = self.pos_emb(positions)\n return x + positions\n\n\nclass LandmarkEmbedding(layers.Layer):\n def __init__(self, num_hid=64, maxlen=100):\n super().__init__()\n self.conv1 = tf.keras.layers.Conv1D(\n num_hid, 11, strides=2, padding=\"same\", activation=\"relu\"\n )\n self.conv2 = tf.keras.layers.Conv1D(\n num_hid, 11, strides=2, padding=\"same\", activation=\"relu\"\n )\n self.conv3 = tf.keras.layers.Conv1D(\n num_hid, 11, strides=2, padding=\"same\", activation=\"relu\"\n )\n self.pos_emb = layers.Embedding(input_dim=maxlen, output_dim=num_hid)\n\n def call(self, x):\n x = self.conv1(x)\n x = self.conv2(x)\n return self.conv3(x)","metadata":{"execution":{"iopub.status.busy":"2023-12-12T13:10:11.775204Z","iopub.execute_input":"2023-12-12T13:10:11.77585Z","iopub.status.idle":"2023-12-12T13:10:11.790917Z","shell.execute_reply.started":"2023-12-12T13:10:11.775813Z","shell.execute_reply":"2023-12-12T13:10:11.789622Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class TransformerEncoder(layers.Layer):\n def __init__(self, embed_dim, num_heads, feed_forward_dim, rate=0.1):\n super().__init__()\n self.att = layers.MultiHeadAttention(num_heads=num_heads, key_dim=embed_dim)\n self.ffn = keras.Sequential(\n [\n layers.Dense(feed_forward_dim, activation=\"relu\"),\n layers.Dense(embed_dim),\n ]\n )\n self.layernorm1 = layers.LayerNormalization(epsilon=1e-6)\n self.layernorm2 = layers.LayerNormalization(epsilon=1e-6)\n self.dropout1 = layers.Dropout(rate)\n self.dropout2 = layers.Dropout(rate)\n\n def call(self, inputs, training):\n attn_output = self.att(inputs, inputs)\n attn_output = self.dropout1(attn_output, training=training)\n out1 = self.layernorm1(inputs + attn_output)\n ffn_output = self.ffn(out1)\n ffn_output = self.dropout2(ffn_output, training=training)\n return self.layernorm2(out1 + ffn_output)","metadata":{"execution":{"iopub.status.busy":"2023-12-12T13:10:11.792601Z","iopub.execute_input":"2023-12-12T13:10:11.793876Z","iopub.status.idle":"2023-12-12T13:10:11.81503Z","shell.execute_reply.started":"2023-12-12T13:10:11.793775Z","shell.execute_reply":"2023-12-12T13:10:11.813795Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Customized to add `training` variable\n# Reference: https://www.kaggle.com/code/shlomoron/aslfr-a-simple-transformer/notebook\n\nclass TransformerDecoder(layers.Layer):\n def __init__(self, embed_dim, num_heads, feed_forward_dim, dropout_rate=0.1):\n super().__init__()\n self.layernorm1 = layers.LayerNormalization(epsilon=1e-6)\n self.layernorm2 = layers.LayerNormalization(epsilon=1e-6)\n self.layernorm3 = layers.LayerNormalization(epsilon=1e-6)\n self.self_att = layers.MultiHeadAttention(\n num_heads=num_heads, key_dim=embed_dim\n )\n self.enc_att = layers.MultiHeadAttention(num_heads=num_heads, key_dim=embed_dim)\n self.self_dropout = layers.Dropout(0.5)\n self.enc_dropout = layers.Dropout(0.1)\n self.ffn_dropout = layers.Dropout(0.1)\n self.ffn = keras.Sequential(\n [\n layers.Dense(feed_forward_dim, activation=\"relu\"),\n layers.Dense(embed_dim),\n ]\n )\n\n def causal_attention_mask(self, batch_size, n_dest, n_src, dtype):\n \"\"\"Masks the upper half of the dot product matrix in self attention.\n\n This prevents flow of information from future tokens to current token.\n 1's in the lower triangle, counting from the lower right corner.\n \"\"\"\n i = tf.range(n_dest)[:, None]\n j = tf.range(n_src)\n m = i >= j - n_src + n_dest\n mask = tf.cast(m, dtype)\n mask = tf.reshape(mask, [1, n_dest, n_src])\n mult = tf.concat(\n [batch_size[..., tf.newaxis], tf.constant([1, 1], dtype=tf.int32)], 0\n )\n return tf.tile(mask, mult)\n\n def call(self, enc_out, target, training):\n input_shape = tf.shape(target)\n batch_size = input_shape[0]\n seq_len = input_shape[1]\n causal_mask = self.causal_attention_mask(batch_size, seq_len, seq_len, tf.bool)\n target_att = self.self_att(target, target, attention_mask=causal_mask)\n target_norm = self.layernorm1(target + self.self_dropout(target_att, training = training))\n enc_out = self.enc_att(target_norm, enc_out)\n enc_out_norm = self.layernorm2(self.enc_dropout(enc_out, training = training) + target_norm)\n ffn_out = self.ffn(enc_out_norm)\n ffn_out_norm = self.layernorm3(enc_out_norm + self.ffn_dropout(ffn_out, training = training))\n return ffn_out_norm","metadata":{"execution":{"iopub.status.busy":"2023-12-12T13:10:11.817583Z","iopub.execute_input":"2023-12-12T13:10:11.81881Z","iopub.status.idle":"2023-12-12T13:10:11.843569Z","shell.execute_reply.started":"2023-12-12T13:10:11.818759Z","shell.execute_reply":"2023-12-12T13:10:11.841082Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Customized to add edit_dist metric and training variable.\n# Reference:\n# https://www.kaggle.com/code/irohith/aslfr-transformer/notebook\n# https://www.kaggle.com/code/shlomoron/aslfr-a-simple-transformer/notebook\n\nclass Transformer(keras.Model):\n def __init__(\n self,\n num_hid=64,\n num_head=2,\n num_feed_forward=128,\n source_maxlen=100,\n target_maxlen=100,\n num_layers_enc=4,\n num_layers_dec=1,\n num_classes=60,\n ):\n super().__init__()\n self.loss_metric = keras.metrics.Mean(name=\"loss\")\n self.acc_metric = keras.metrics.Mean(name=\"edit_dist\")\n self.num_layers_enc = num_layers_enc\n self.num_layers_dec = num_layers_dec\n self.target_maxlen = target_maxlen\n self.num_classes = num_classes\n\n self.enc_input = LandmarkEmbedding(num_hid=num_hid, maxlen=source_maxlen)\n self.dec_input = TokenEmbedding(\n num_vocab=num_classes, maxlen=target_maxlen, num_hid=num_hid\n )\n\n self.encoder = keras.Sequential(\n [self.enc_input]\n + [\n TransformerEncoder(num_hid, num_head, num_feed_forward)\n for _ in range(num_layers_enc)\n ]\n )\n\n for i in range(num_layers_dec):\n setattr(\n self,\n f\"dec_layer_{i}\",\n TransformerDecoder(num_hid, num_head, num_feed_forward),\n )\n\n self.classifier = layers.Dense(num_classes)\n\n def decode(self, enc_out, target, training):\n y = self.dec_input(target)\n for i in range(self.num_layers_dec):\n y = getattr(self, f\"dec_layer_{i}\")(enc_out, y, training)\n return y\n\n def call(self, inputs, training):\n source = inputs[0]\n target = inputs[1]\n x = self.encoder(source, training)\n y = self.decode(x, target, training)\n return self.classifier(y)\n\n @property\n def metrics(self):\n return [self.loss_metric]\n\n def train_step(self, batch):\n \"\"\"Processes one batch inside model.fit().\"\"\"\n source = batch[0]\n target = batch[1]\n\n input_shape = tf.shape(target)\n batch_size = input_shape[0]\n \n dec_input = target[:, :-1]\n dec_target = target[:, 1:]\n with tf.GradientTape() as tape:\n preds = self([source, dec_input])\n one_hot = tf.one_hot(dec_target, depth=self.num_classes)\n mask = tf.math.logical_not(tf.math.equal(dec_target, pad_token_idx))\n loss = self.compiled_loss(one_hot, preds, sample_weight=mask)\n trainable_vars = self.trainable_variables\n gradients = tape.gradient(loss, trainable_vars)\n self.optimizer.apply_gradients(zip(gradients, trainable_vars))\n # Computes the Levenshtein distance between sequences since the evaluation\n # metric for this contest is the normalized total levenshtein distance.\n edit_dist = tf.edit_distance(tf.sparse.from_dense(target), \n tf.sparse.from_dense(tf.cast(tf.argmax(preds, axis=1), tf.int32)))\n edit_dist = tf.reduce_mean(edit_dist)\n self.acc_metric.update_state(edit_dist)\n self.loss_metric.update_state(loss)\n return {\"loss\": self.loss_metric.result(), \"edit_dist\": self.acc_metric.result()}\n\n def test_step(self, batch): \n source = batch[0]\n target = batch[1]\n\n input_shape = tf.shape(target)\n batch_size = input_shape[0]\n \n dec_input = target[:, :-1]\n dec_target = target[:, 1:]\n preds = self([source, dec_input])\n one_hot = tf.one_hot(dec_target, depth=self.num_classes)\n mask = tf.math.logical_not(tf.math.equal(dec_target, pad_token_idx))\n loss = self.compiled_loss(one_hot, preds, sample_weight=mask)\n # Computes the Levenshtein distance between sequences since the evaluation\n # metric for this contest is the normalized total levenshtein distance.\n edit_dist = tf.edit_distance(tf.sparse.from_dense(target), \n tf.sparse.from_dense(tf.cast(tf.argmax(preds, axis=1), tf.int32)))\n edit_dist = tf.reduce_mean(edit_dist)\n self.acc_metric.update_state(edit_dist)\n self.loss_metric.update_state(loss)\n return {\"loss\": self.loss_metric.result(), \"edit_dist\": self.acc_metric.result()}\n\n def generate(self, source, target_start_token_idx):\n \"\"\"Performs inference over one batch of inputs using greedy decoding.\"\"\"\n bs = tf.shape(source)[0]\n enc = self.encoder(source, training = False)\n dec_input = tf.ones((bs, 1), dtype=tf.int32) * target_start_token_idx\n dec_logits = []\n for i in range(self.target_maxlen - 1):\n dec_out = self.decode(enc, dec_input, training = False)\n logits = self.classifier(dec_out)\n logits = tf.argmax(logits, axis=-1, output_type=tf.int32)\n last_logit = logits[:, -1][..., tf.newaxis]\n dec_logits.append(last_logit)\n dec_input = tf.concat([dec_input, last_logit], axis=-1)\n return dec_input","metadata":{"execution":{"iopub.status.busy":"2023-12-12T13:10:11.845171Z","iopub.execute_input":"2023-12-12T13:10:11.84564Z","iopub.status.idle":"2023-12-12T13:10:11.885283Z","shell.execute_reply.started":"2023-12-12T13:10:11.845592Z","shell.execute_reply":"2023-12-12T13:10:11.883454Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class DisplayOutputs(keras.callbacks.Callback):\n def __init__(\n self, batch, idx_to_token, target_start_token_idx=60, target_end_token_idx=61\n ):\n \"\"\"Displays a batch of outputs after every 4 epoch\n\n Args:\n batch: A test batch\n idx_to_token: A List containing the vocabulary tokens corresponding to their indices\n target_start_token_idx: A start token index in the target vocabulary\n target_end_token_idx: An end token index in the target vocabulary\n \"\"\"\n self.batch = batch\n self.target_start_token_idx = target_start_token_idx\n self.target_end_token_idx = target_end_token_idx\n self.idx_to_char = idx_to_token\n\n def on_epoch_end(self, epoch, logs=None):\n if epoch % 4 != 0:\n return\n source = self.batch[0]\n target = self.batch[1].numpy()\n bs = tf.shape(source)[0]\n preds = self.model.generate(source, self.target_start_token_idx)\n preds = preds.numpy()\n for i in range(bs):\n target_text = \"\".join([self.idx_to_char[_] for _ in target[i, :]])\n prediction = \"\"\n for idx in preds[i, :]:\n prediction += self.idx_to_char[idx]\n if idx == self.target_end_token_idx:\n break\n print(f\"target: {target_text.replace('-','')}\")\n print(f\"prediction: {prediction}\\n\")","metadata":{"execution":{"iopub.status.busy":"2023-12-12T13:10:11.888533Z","iopub.execute_input":"2023-12-12T13:10:11.889404Z","iopub.status.idle":"2023-12-12T13:10:11.908826Z","shell.execute_reply.started":"2023-12-12T13:10:11.889317Z","shell.execute_reply":"2023-12-12T13:10:11.907273Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Transformer variables are customized from original keras tutorial to suit this dataset.\n# Reference: https://www.kaggle.com/code/shlomoron/aslfr-a-simple-transformer/notebook\n\nbatch = next(iter(valid_ds))\n\n# The vocabulary to convert predicted indices into characters\nidx_to_char = list(char_to_num.keys())\ndisplay_cb = DisplayOutputs(\n batch, idx_to_char, target_start_token_idx=char_to_num['<'], target_end_token_idx=char_to_num['>']\n) # set the arguments as per vocabulary index for '<' and '>'\n\nmodel = Transformer(\n num_hid=200,\n num_head=4,\n num_feed_forward=400,\n source_maxlen = FRAME_LEN,\n target_maxlen=64,\n num_layers_enc=2,\n num_layers_dec=1,\n num_classes=62\n)\nloss_fn = tf.keras.losses.CategoricalCrossentropy(\n from_logits=True, label_smoothing=0.1,\n)\n\n\noptimizer = keras.optimizers.Adam(0.0001)\nmodel.compile(optimizer=optimizer, loss=loss_fn)\n\nhistory = model.fit(train_ds, validation_data=valid_ds, callbacks=[display_cb], epochs=13)","metadata":{"execution":{"iopub.status.busy":"2023-12-12T13:10:11.911082Z","iopub.execute_input":"2023-12-12T13:10:11.912029Z","iopub.status.idle":"2023-12-12T15:14:22.20049Z","shell.execute_reply.started":"2023-12-12T13:10:11.911958Z","shell.execute_reply":"2023-12-12T15:14:22.199102Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_loss, test_accuracy = model.evaluate(train_ds)\nprint(f'Test Accuracy: {test_accuracy * 100:.2f}%')","metadata":{"execution":{"iopub.status.busy":"2023-12-12T15:22:07.910747Z","iopub.execute_input":"2023-12-12T15:22:07.911273Z","iopub.status.idle":"2023-12-12T15:25:29.837238Z","shell.execute_reply.started":"2023-12-12T15:22:07.911234Z","shell.execute_reply":"2023-12-12T15:25:29.835514Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.plot(history.history['loss'])\nplt.plot(history.history['val_loss'])\nplt.legend(['training loss', 'val_loss'])","metadata":{"execution":{"iopub.status.busy":"2023-12-12T15:55:55.96559Z","iopub.execute_input":"2023-12-12T15:55:55.966239Z","iopub.status.idle":"2023-12-12T15:55:56.405955Z","shell.execute_reply.started":"2023-12-12T15:55:55.966189Z","shell.execute_reply":"2023-12-12T15:55:56.404822Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nclass TFLiteModel(tf.Module):\n def __init__(self, model):\n super(TFLiteModel, self).__init__()\n self.target_start_token_idx = start_token_idx\n self.target_end_token_idx = end_token_idx\n # Load the feature generation and main models\n self.model = model\n \n @tf.function(input_signature=[tf.TensorSpec(shape=[None, len(FEATURE_COLUMNS)], dtype=tf.float32, name='inputs')])\n def __call__(self, inputs, training=False):\n # Preprocess Data\n x = tf.cast(inputs, tf.float32)\n x = x[None]\n x = tf.cond(tf.shape(x)[1] == 0, lambda: tf.zeros((1, 1, len(FEATURE_COLUMNS))), lambda: tf.identity(x))\n x = x[0]\n x = pre_process(x)\n x = x[None]\n x = self.model.generate(x, self.target_start_token_idx)\n x = x[0]\n idx = tf.argmax(tf.cast(tf.equal(x, self.target_end_token_idx), tf.int32))\n idx = tf.where(tf.math.less(idx, 1), tf.constant(2, dtype=tf.int64), idx)\n x = x[1:idx]\n x = tf.one_hot(x, 59)\n return {'outputs': x}\n \ntflitemodel_base = TFLiteModel(model)\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2023-12-12T15:14:22.266668Z","iopub.status.idle":"2023-12-12T15:14:22.267291Z","shell.execute_reply.started":"2023-12-12T15:14:22.267033Z","shell.execute_reply":"2023-12-12T15:14:22.267056Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nmodel.save_weights(\"model.h5\")\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2023-12-12T15:14:22.269882Z","iopub.status.idle":"2023-12-12T15:14:22.270633Z","shell.execute_reply.started":"2023-12-12T15:14:22.270263Z","shell.execute_reply":"2023-12-12T15:14:22.270291Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\nkeras_model_converter = tf.lite.TFLiteConverter.from_keras_model(tflitemodel_base)\nkeras_model_converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS]#, tf.lite.OpsSet.SELECT_TF_OPS]\ntflite_model = keras_model_converter.convert()\nwith open('/kaggle/working/model.tflite', 'wb') as f:\n f.write(tflite_model)\n \ninfargs = {\"selected_columns\" : FEATURE_COLUMNS}\n\nwith open('inference_args.json', \"w\") as json_file:\n json.dump(infargs, json_file)\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2023-12-12T15:14:22.272569Z","iopub.status.idle":"2023-12-12T15:14:22.273227Z","shell.execute_reply.started":"2023-12-12T15:14:22.272931Z","shell.execute_reply":"2023-12-12T15:14:22.272959Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\n!zip submission.zip './model.tflite' './inference_args.json'\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2023-12-12T15:14:22.275962Z","iopub.status.idle":"2023-12-12T15:14:22.276506Z","shell.execute_reply.started":"2023-12-12T15:14:22.276266Z","shell.execute_reply":"2023-12-12T15:14:22.27629Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\"\"\"\ninterpreter = tf.lite.Interpreter(\"model.tflite\")\n\nREQUIRED_SIGNATURE = \"serving_default\"\nREQUIRED_OUTPUT = \"outputs\"\n\nwith open (\"/kaggle/input/asl-fingerspelling/character_to_prediction_index.json\", \"r\") as f:\n character_map = json.load(f)\nrev_character_map = {j:i for i,j in character_map.items()}\n\nfound_signatures = list(interpreter.get_signature_list().keys())\n\nif REQUIRED_SIGNATURE not in found_signatures:\n raise KernelEvalException('Required input signature not found.')\n\nprediction_fn = interpreter.get_signature_runner(\"serving_default\")\noutput = prediction_fn(inputs=batch[0][0])\nprediction_str = \"\".join([rev_character_map.get(s, \"\") for s in np.argmax(output[REQUIRED_OUTPUT], axis=1)])\nprint(prediction_str)\n\"\"\"","metadata":{"execution":{"iopub.status.busy":"2023-12-12T15:14:22.27756Z","iopub.status.idle":"2023-12-12T15:14:22.278236Z","shell.execute_reply.started":"2023-12-12T15:14:22.277915Z","shell.execute_reply":"2023-12-12T15:14:22.277993Z"},"trusted":true},"execution_count":null,"outputs":[]}]}