{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.7.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"nvidiaTeslaT4","dataSources":[{"sourceId":46105,"databundleVersionId":5087314,"sourceType":"competition"},{"sourceId":5600436,"sourceType":"datasetVersion","datasetId":3221731}],"dockerImageVersionId":30408,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"**NOTE: This submission utilizes the maximum inference time limit, so depending on the situation, a submission scoring error may occur. \n\nHowever, you can succeed by trying multiple times.**","metadata":{}},{"cell_type":"code","source":"# import tensorflow as tf\n# import numpy as np\n# import pandas as pd\n# import json\n# import os\n# from multiprocessing import cpu_count\n\n# def read_json_file(file_path):\n#     \"\"\"Read a JSON file and parse it into a Python object.\n\n#     Args:\n#         file_path (str): The path to the JSON file to read.\n\n#     Returns:\n#         dict: A dictionary object representing the JSON data.\n        \n#     Raises:\n#         FileNotFoundError: If the specified file path does not exist.\n#         ValueError: If the specified file path does not contain valid JSON data.\n#     \"\"\"\n#     try:\n#         # Open the file and load the JSON data into a Python object\n#         with open(file_path, 'r') as file:\n#             json_data = json.load(file)\n#         return json_data\n#     except FileNotFoundError:\n#         # Raise an error if the file path does not exist\n#         raise FileNotFoundError(f\"File not found: {file_path}\")\n#     except ValueError:\n#         # Raise an error if the file does not contain valid JSON data\n#         raise ValueError(f\"Invalid JSON data in file: {file_path}\")\n\n# cpu_count()","metadata":{"execution":{"iopub.status.busy":"2024-11-28T02:35:36.472499Z","iopub.execute_input":"2024-11-28T02:35:36.473278Z","iopub.status.idle":"2024-11-28T02:35:36.539094Z","shell.execute_reply.started":"2024-11-28T02:35:36.473228Z","shell.execute_reply":"2024-11-28T02:35:36.537877Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# train_df = pd.read_csv('/kaggle/input/asl-signs/train.csv')\n# print(\"\\n\\n... LOAD SIGN TO PREDICTION INDEX MAP FROM JSON FILE ...\\n\")\n# s2p_map = {k.lower():v for k,v in read_json_file(os.path.join(\"/kaggle/input/asl-signs/sign_to_prediction_index_map.json\")).items()}\n# p2s_map = {v:k for k,v in read_json_file(os.path.join(\"/kaggle/input/asl-signs/sign_to_prediction_index_map.json\")).items()}\n# encoder = lambda x: s2p_map.get(x.lower())\n# decoder = lambda x: p2s_map.get(x)\n# # print(s2p_map)\n# train_df['label'] = train_df.sign.map(encoder)","metadata":{"execution":{"iopub.status.busy":"2024-11-28T02:35:36.540720Z","iopub.execute_input":"2024-11-28T02:35:36.541015Z","iopub.status.idle":"2024-11-28T02:35:36.544889Z","shell.execute_reply.started":"2024-11-28T02:35:36.540990Z","shell.execute_reply":"2024-11-28T02:35:36.543923Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ROWS_PER_FRAME = 543\n# MAX_LEN = 384\n# CROP_LEN = MAX_LEN\n# NUM_CLASSES  = 250\n# PAD = -100.\n# NOSE=[\n#     1,2,98,327\n# ]\n# LNOSE = [98]\n# RNOSE = [327]\n# LIP = [ 0, \n#     61, 185, 40, 39, 37, 267, 269, 270, 409,\n#     291, 146, 91, 181, 84, 17, 314, 405, 321, 375,\n#     78, 191, 80, 81, 82, 13, 312, 311, 310, 415,\n#     95, 88, 178, 87, 14, 317, 402, 318, 324, 308,\n# ]\n# LLIP = [84,181,91,146,61,185,40,39,37,87,178,88,95,78,191,80,81,82]\n# RLIP = [314,405,321,375,291,409,270,269,267,317,402,318,324,308,415,310,311,312]\n\n# POSE = [500, 502, 504, 501, 503, 505, 512, 513]\n# LPOSE = [513,505,503,501]\n# RPOSE = [512,504,502,500]\n\n# REYE = [\n#     33, 7, 163, 144, 145, 153, 154, 155, 133,\n#     246, 161, 160, 159, 158, 157, 173,\n# ]\n# LEYE = [\n#     263, 249, 390, 373, 374, 380, 381, 382, 362,\n#     466, 388, 387, 386, 385, 384, 398,\n# ]\n\n# LHAND = np.arange(468, 489).tolist()\n# RHAND = np.arange(522, 543).tolist()\n\n# POINT_LANDMARKS = LIP + LHAND + RHAND + NOSE + REYE + LEYE #+POSE\n\n# NUM_NODES = len(POINT_LANDMARKS)\n# CHANNELS = 6*NUM_NODES\n\n# print(NUM_NODES)\n# print(CHANNELS)\n\n# def tf_nan_mean(x, axis=0, keepdims=False):\n#     return tf.reduce_sum(tf.where(tf.math.is_nan(x), tf.zeros_like(x), x), axis=axis, keepdims=keepdims) / tf.reduce_sum(tf.where(tf.math.is_nan(x), tf.zeros_like(x), tf.ones_like(x)), axis=axis, keepdims=keepdims)\n\n# def tf_nan_std(x, center=None, axis=0, keepdims=False):\n#     if center is None:\n#         center = tf_nan_mean(x, axis=axis,  keepdims=True)\n#     d = x - center\n#     return tf.math.sqrt(tf_nan_mean(d * d, axis=axis, keepdims=keepdims))\n\n# class Preprocess(tf.keras.layers.Layer):\n#     def __init__(self, max_len=MAX_LEN, point_landmarks=POINT_LANDMARKS, **kwargs):\n#         super().__init__(**kwargs)\n#         self.max_len = max_len\n#         self.point_landmarks = point_landmarks\n\n#     def call(self, inputs):\n#         if tf.rank(inputs) == 3:\n#             x = inputs[None,...]\n#         else:\n#             x = inputs\n        \n#         mean = tf_nan_mean(tf.gather(x, [17], axis=2), axis=[1,2], keepdims=True)\n#         mean = tf.where(tf.math.is_nan(mean), tf.constant(0.5,x.dtype), mean)\n#         x = tf.gather(x, self.point_landmarks, axis=2) #N,T,P,C\n#         std = tf_nan_std(x, center=mean, axis=[1,2], keepdims=True)\n        \n#         x = (x - mean)/std\n\n#         if self.max_len is not None:\n#             x = x[:,:self.max_len]\n#         length = tf.shape(x)[1]\n#         x = x[...,:2]\n\n#         dx = tf.cond(tf.shape(x)[1]>1,lambda:tf.pad(x[:,1:] - x[:,:-1], [[0,0],[0,1],[0,0],[0,0]]),lambda:tf.zeros_like(x))\n\n#         dx2 = tf.cond(tf.shape(x)[1]>2,lambda:tf.pad(x[:,2:] - x[:,:-2], [[0,0],[0,2],[0,0],[0,0]]),lambda:tf.zeros_like(x))\n\n#         x = tf.concat([\n#             tf.reshape(x, (-1,length,2*len(self.point_landmarks))),\n#             tf.reshape(dx, (-1,length,2*len(self.point_landmarks))),\n#             tf.reshape(dx2, (-1,length,2*len(self.point_landmarks))),\n#         ], axis = -1)\n        \n#         x = tf.where(tf.math.is_nan(x),tf.constant(0.,x.dtype),x)\n        \n#         return x","metadata":{"execution":{"iopub.status.busy":"2024-11-28T02:35:36.546012Z","iopub.execute_input":"2024-11-28T02:35:36.546281Z","iopub.status.idle":"2024-11-28T02:35:36.557956Z","shell.execute_reply.started":"2024-11-28T02:35:36.546247Z","shell.execute_reply":"2024-11-28T02:35:36.557239Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# class ECA(tf.keras.layers.Layer):\n#     def __init__(self, kernel_size=5, **kwargs):\n#         super().__init__(**kwargs)\n#         self.supports_masking = True\n#         self.kernel_size = kernel_size\n#         self.conv = tf.keras.layers.Conv1D(1, kernel_size=kernel_size, strides=1, padding=\"same\", use_bias=False)\n\n#     def call(self, inputs, mask=None):\n#         nn = tf.keras.layers.GlobalAveragePooling1D()(inputs, mask=mask)\n#         nn = tf.expand_dims(nn, -1)\n#         nn = self.conv(nn)\n#         nn = tf.squeeze(nn, -1)\n#         nn = tf.nn.sigmoid(nn)\n#         nn = nn[:,None,:]\n#         return inputs * nn\n\n# class LateDropout(tf.keras.layers.Layer):\n#     def __init__(self, rate, noise_shape=None, start_step=0, **kwargs):\n#         super().__init__(**kwargs)\n#         self.supports_masking = True\n#         self.rate = rate\n#         self.start_step = start_step\n#         self.dropout = tf.keras.layers.Dropout(rate, noise_shape=noise_shape)\n      \n#     def build(self, input_shape):\n#         super().build(input_shape)\n#         agg = tf.VariableAggregation.ONLY_FIRST_REPLICA\n#         self._train_counter = tf.Variable(0, dtype=\"int64\", aggregation=agg, trainable=False)\n\n#     def call(self, inputs, training=False):\n#         x = tf.cond(self._train_counter < self.start_step, lambda:inputs, lambda:self.dropout(inputs, training=training))\n#         if training:\n#             self._train_counter.assign_add(1)\n#         return x\n\n# class CausalDWConv1D(tf.keras.layers.Layer):\n#     def __init__(self, \n#         kernel_size=17,\n#         dilation_rate=1,\n#         use_bias=False,\n#         depthwise_initializer='glorot_uniform',\n#         name='', **kwargs):\n#         super().__init__(name=name,**kwargs)\n#         self.causal_pad = tf.keras.layers.ZeroPadding1D((dilation_rate*(kernel_size-1),0),name=name + '_pad')\n#         self.dw_conv = tf.keras.layers.DepthwiseConv1D(\n#                             kernel_size,\n#                             strides=1,\n#                             dilation_rate=dilation_rate,\n#                             padding='valid',\n#                             use_bias=use_bias,\n#                             depthwise_initializer=depthwise_initializer,\n#                             name=name + '_dwconv')\n#         self.supports_masking = True\n        \n#     def call(self, inputs):\n#         x = self.causal_pad(inputs)\n#         x = self.dw_conv(x)\n#         return x\n\n# def Conv1DBlock(channel_size,\n#           kernel_size,\n#           dilation_rate=1,\n#           drop_rate=0.0,\n#           expand_ratio=2,\n#           se_ratio=0.25,\n#           activation='swish',\n#           name=None):\n#     '''\n#     efficient conv1d block, @hoyso48\n#     '''\n#     if name is None:\n#         name = str(tf.keras.backend.get_uid(\"mbblock\"))\n#     # Expansion phase\n#     def apply(inputs):\n#         channels_in = tf.keras.backend.int_shape(inputs)[-1]\n#         channels_expand = channels_in * expand_ratio\n\n#         skip = inputs\n\n#         x = tf.keras.layers.Dense(\n#             channels_expand,\n#             use_bias=True,\n#             activation=activation,\n#             name=name + '_expand_conv')(inputs)\n\n#         # Depthwise Convolution\n#         x = CausalDWConv1D(kernel_size,\n#             dilation_rate=dilation_rate,\n#             use_bias=False,\n#             name=name + '_dwconv')(x)\n\n#         x = tf.keras.layers.BatchNormalization(momentum=0.95, name=name + '_bn')(x)\n\n#         x  = ECA()(x)\n\n#         x = tf.keras.layers.Dense(\n#             channel_size,\n#             use_bias=True,\n#             name=name + '_project_conv')(x)\n\n#         if drop_rate > 0:\n#             x = tf.keras.layers.Dropout(drop_rate, noise_shape=(None,1,1), name=name + '_drop')(x)\n\n#         if (channels_in == channel_size):\n#             x = tf.keras.layers.add([x, skip], name=name + '_add')\n#         return x\n\n#     return apply","metadata":{"execution":{"iopub.status.busy":"2024-11-28T02:35:36.559015Z","iopub.execute_input":"2024-11-28T02:35:36.559257Z","iopub.status.idle":"2024-11-28T02:35:36.577461Z","shell.execute_reply.started":"2024-11-28T02:35:36.559235Z","shell.execute_reply":"2024-11-28T02:35:36.576730Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# class MultiHeadSelfAttention(tf.keras.layers.Layer):\n#     def __init__(self, dim=256, num_heads=4, dropout=0, **kwargs):\n#         super().__init__(**kwargs)\n#         self.dim = dim\n#         self.scale = self.dim ** -0.5\n#         self.num_heads = num_heads\n#         self.qkv = tf.keras.layers.Dense(3 * dim, use_bias=False)\n#         self.drop1 = tf.keras.layers.Dropout(dropout)\n#         self.proj = tf.keras.layers.Dense(dim, use_bias=False)\n#         self.supports_masking = True\n\n#     def call(self, inputs, mask=None):\n#         qkv = self.qkv(inputs)\n#         qkv = tf.keras.layers.Permute((2, 1, 3))(tf.keras.layers.Reshape((-1, self.num_heads, self.dim * 3 // self.num_heads))(qkv))\n#         q, k, v = tf.split(qkv, [self.dim // self.num_heads] * 3, axis=-1)\n\n#         attn = tf.matmul(q, k, transpose_b=True) * self.scale\n\n#         if mask is not None:\n#             mask = mask[:, None, None, :]\n\n#         attn = tf.keras.layers.Softmax(axis=-1)(attn, mask=mask)\n#         attn = self.drop1(attn)\n\n#         x = attn @ v\n#         x = tf.keras.layers.Reshape((-1, self.dim))(tf.keras.layers.Permute((2, 1, 3))(x))\n#         x = self.proj(x)\n#         return x\n\n\n# def TransformerBlock(dim=256, num_heads=4, expand=4, attn_dropout=0.2, drop_rate=0.2, activation='swish'):\n#     def apply(inputs):\n#         x = inputs\n#         x = tf.keras.layers.BatchNormalization(momentum=0.95)(x)\n#         x = MultiHeadSelfAttention(dim=dim,num_heads=num_heads,dropout=attn_dropout)(x)\n#         x = tf.keras.layers.Dropout(drop_rate, noise_shape=(None,1,1))(x)\n#         x = tf.keras.layers.Add()([inputs, x])\n#         attn_out = x\n\n#         x = tf.keras.layers.BatchNormalization(momentum=0.95)(x)\n#         x = tf.keras.layers.Dense(dim*expand, use_bias=False, activation=activation)(x)\n#         x = tf.keras.layers.Dense(dim, use_bias=False)(x)\n#         x = tf.keras.layers.Dropout(drop_rate, noise_shape=(None,1,1))(x)\n#         x = tf.keras.layers.Add()([attn_out, x])\n#         return x\n#     return apply","metadata":{"execution":{"iopub.status.busy":"2024-11-28T02:35:36.580594Z","iopub.execute_input":"2024-11-28T02:35:36.580860Z","iopub.status.idle":"2024-11-28T02:35:36.593196Z","shell.execute_reply.started":"2024-11-28T02:35:36.580834Z","shell.execute_reply":"2024-11-28T02:35:36.592262Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# def get_model(max_len=MAX_LEN, dropout_step=0, dim=192):\n#     inp = tf.keras.Input((max_len,CHANNELS))\n#     #x = tf.keras.layers.Masking(mask_value=PAD,input_shape=(max_len,CHANNELS))(inp) #we don't need masking layer with inference\n#     x = inp\n#     ksize = 17\n#     x = tf.keras.layers.Dense(dim, use_bias=False,name='stem_conv')(x)\n#     x = tf.keras.layers.BatchNormalization(momentum=0.95,name='stem_bn')(x)\n\n#     x = Conv1DBlock(dim,ksize,drop_rate=0.2)(x)\n#     x = Conv1DBlock(dim,ksize,drop_rate=0.2)(x)\n#     x = Conv1DBlock(dim,ksize,drop_rate=0.2)(x)\n#     x = TransformerBlock(dim,expand=2)(x)\n\n#     x = Conv1DBlock(dim,ksize,drop_rate=0.2)(x)\n#     x = Conv1DBlock(dim,ksize,drop_rate=0.2)(x)\n#     x = Conv1DBlock(dim,ksize,drop_rate=0.2)(x)\n#     x = TransformerBlock(dim,expand=2)(x)\n\n#     if dim == 384: #for the 4x sized model\n#         x = Conv1DBlock(dim,ksize,drop_rate=0.2)(x)\n#         x = Conv1DBlock(dim,ksize,drop_rate=0.2)(x)\n#         x = Conv1DBlock(dim,ksize,drop_rate=0.2)(x)\n#         x = TransformerBlock(dim,expand=2)(x)\n\n#         x = Conv1DBlock(dim,ksize,drop_rate=0.2)(x)\n#         x = Conv1DBlock(dim,ksize,drop_rate=0.2)(x)\n#         x = Conv1DBlock(dim,ksize,drop_rate=0.2)(x)\n#         x = TransformerBlock(dim,expand=2)(x)\n\n#     x = tf.keras.layers.Dense(dim*2,activation=None,name='top_conv')(x)\n#     x = tf.keras.layers.GlobalAveragePooling1D()(x)\n#     x = LateDropout(0.8, start_step=dropout_step)(x)\n#     x = tf.keras.layers.Dense(NUM_CLASSES,name='classifier')(x)\n#     return tf.keras.Model(inp, x)","metadata":{"execution":{"iopub.status.busy":"2024-11-28T02:35:36.594426Z","iopub.execute_input":"2024-11-28T02:35:36.595285Z","iopub.status.idle":"2024-11-28T02:35:36.609013Z","shell.execute_reply.started":"2024-11-28T02:35:36.595252Z","shell.execute_reply":"2024-11-28T02:35:36.608280Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# models_path = [\n#               '/kaggle/input/islr-models/islr-fp16-192-8-seed42-foldall-last.h5', #comment out other weights to check single model score\n#                '/kaggle/input/islr-models/islr-fp16-192-8-seed43-foldall-last.h5',\n#                '/kaggle/input/islr-models/islr-fp16-192-8-seed44-foldall-last.h5',\n#                #'/kaggle/input/islr-models/islr-fp16-192-8-seed45-foldall-last.h5',\n#               ]\n# models = [get_model() for _ in models_path]\n# for model,path in zip(models,models_path):\n#     model.load_weights(path)\n# models[0].summary()","metadata":{"execution":{"iopub.status.busy":"2024-11-28T02:35:36.610202Z","iopub.execute_input":"2024-11-28T02:35:36.610967Z","iopub.status.idle":"2024-11-28T02:35:36.619975Z","shell.execute_reply.started":"2024-11-28T02:35:36.610931Z","shell.execute_reply":"2024-11-28T02:35:36.619303Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# class TFLiteModel(tf.Module):\n#     \"\"\"\n#     TensorFlow Lite model that takes input tensors and applies:\n#         – a preprocessing model\n#         – the ISLR model \n#     \"\"\"\n\n#     def __init__(self, islr_models):\n#         \"\"\"\n#         Initializes the TFLiteModel with the specified preprocessing model and ISLR model.\n#         \"\"\"\n#         super(TFLiteModel, self).__init__()\n\n#         # Load the feature generation and main models\n#         self.prep_inputs = Preprocess()\n#         self.islr_models   = islr_models\n    \n#     @tf.function(input_signature=[tf.TensorSpec(shape=[None, 543, 3], dtype=tf.float32, name='inputs')])\n#     def __call__(self, inputs):\n#         \"\"\"\n#         Applies the feature generation model and main model to the input tensors.\n\n#         Args:\n#             inputs: Input tensor with shape [batch_size, 543, 3].\n\n#         Returns:\n#             A dictionary with a single key 'outputs' and corresponding output tensor.\n#         \"\"\"\n#         x = self.prep_inputs(tf.cast(inputs, dtype=tf.float32))\n#         outputs = [model(x) for model in self.islr_models]\n#         outputs = tf.keras.layers.Average()(outputs)[0]\n#         return {'outputs': outputs}","metadata":{"execution":{"iopub.status.busy":"2024-11-28T02:35:36.621003Z","iopub.execute_input":"2024-11-28T02:35:36.621249Z","iopub.status.idle":"2024-11-28T02:35:36.637046Z","shell.execute_reply.started":"2024-11-28T02:35:36.621227Z","shell.execute_reply":"2024-11-28T02:35:36.636320Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ROWS_PER_FRAME = 543  # number of landmarks per frame\n# def load_relevant_data_subset(pq_path):\n#     data_columns = ['x', 'y', 'z']\n#     data = pd.read_parquet('/kaggle/input/asl-signs/' + pq_path, columns=data_columns)\n#     n_frames = int(len(data) / ROWS_PER_FRAME)\n#     data = data.values.reshape(n_frames, ROWS_PER_FRAME, len(data_columns))\n#     return data.astype(np.float32)","metadata":{"execution":{"iopub.status.busy":"2024-11-28T02:35:36.637978Z","iopub.execute_input":"2024-11-28T02:35:36.638241Z","iopub.status.idle":"2024-11-28T02:35:36.652517Z","shell.execute_reply.started":"2024-11-28T02:35:36.638219Z","shell.execute_reply":"2024-11-28T02:35:36.651852Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# !pip install pyarrow\n# !pip install fastparquet\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-28T02:35:36.653452Z","iopub.execute_input":"2024-11-28T02:35:36.653692Z","iopub.status.idle":"2024-11-28T02:35:36.667996Z","shell.execute_reply.started":"2024-11-28T02:35:36.653668Z","shell.execute_reply":"2024-11-28T02:35:36.667112Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# tflite_keras_model = TFLiteModel(islr_models=models)\n# demo_output = tflite_keras_model(load_relevant_data_subset(train_df.path[0]))[\"outputs\"]\n# decoder(np.argmax(demo_output.numpy(), axis=-1))","metadata":{"execution":{"iopub.status.busy":"2024-11-28T02:35:36.668961Z","iopub.execute_input":"2024-11-28T02:35:36.669170Z","iopub.status.idle":"2024-11-28T02:35:36.681724Z","shell.execute_reply.started":"2024-11-28T02:35:36.669150Z","shell.execute_reply":"2024-11-28T02:35:36.680849Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# keras_model_converter = tf.lite.TFLiteConverter.from_keras_model(tflite_keras_model)\n# keras_model_converter.optimizations = [tf.lite.Optimize.DEFAULT]\n# keras_model_converter.target_spec.supported_types = [tf.float16]\n# tflite_model = keras_model_converter.convert()\n# with open('/kaggle/working/model.tflite', 'wb') as f:\n#     f.write(tflite_model)\n# !zip submission.zip /kaggle/working/model.tflitepip uninstall -y tflite-runtime tensorflow\n","metadata":{"execution":{"iopub.status.busy":"2024-11-28T02:35:36.682830Z","iopub.execute_input":"2024-11-28T02:35:36.683096Z","iopub.status.idle":"2024-11-28T02:35:36.693952Z","shell.execute_reply.started":"2024-11-28T02:35:36.683073Z","shell.execute_reply":"2024-11-28T02:35:36.693014Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# #check inference time\n# #code from @hengck23\n# mode = 's' #'d'ebug #'s'ubmit\n\n# import pandas as pd\n# import numpy as np\n# import os\n# import shutil\n# from datetime import datetime\n# from timeit import default_timer as timer\n\n\n# if mode in ['d']:  \n#     try:\n#         import tflite_runtime\n#     except:\n#         !pip install tflite-runtime\n\n#     import tflite_runtime.interpreter as tflite   \n#     import tflite_runtime\n#     print(tflite_runtime.__version__)\n\n# print('import ok')\n# '''\n# Your model must also require less than 40 MB in memory and \n# perform inference with less than 100 milliseconds of latency per video. \n# Expect to see approximately 40,000 videos in the test set. \n# We allow an additional 10 minute buffer for loading the data and miscellaneous overhead.\n\n# '''\n# def time_to_str(t, mode='min'):\n#     if mode=='min':\n#         t  = int(t)/60\n#         hr = t//60\n#         min = t%60\n#         return '%2d hr %02d min'%(hr,min)\n\n#     elif mode=='sec':\n#         t   = int(t)\n#         min = t//60\n#         sec = t%60\n#         return '%2d min %02d sec'%(min,sec)\n\n#     else:\n#         raise NotImplementedError\n\n        \n# ROWS_PER_FRAME = 543\n# def load_relevant_data_subset(pq_path):\n#     data_columns = ['x', 'y', 'z']\n#     data = pd.read_parquet(pq_path, columns=data_columns)\n#     n_frames = int(len(data) / ROWS_PER_FRAME)\n#     data = data.values.reshape(n_frames, ROWS_PER_FRAME, len(data_columns))\n#     return data.astype(np.float32)\n\n# if mode in ['d']: \n \n#     interpreter = tflite.Interpreter('/kaggle/working/model.tflite')\n#     prediction_fn = interpreter.get_signature_runner('serving_default')\n# #     valid_df = pd.read_csv('/kaggle/input/asl-demo/train_prepared.csv') \n# #     valid_df = train_df[train_df.fold==0].reset_index(drop=True)\n# #     valid_df = valid_df[:1000]\n#     valid_df = train_df[:1000]\n#     valid_num = len(valid_df)\n#     valid = {\n#         'sign':[],\n#     }\n\n#     start_timer = timer()\n#     for t, d in valid_df.iterrows():\n\n#         pq_file = f'/kaggle/input/asl-signs/{d.path}'\n#         #print(pq_file)\n#         xyz = load_relevant_data_subset(pq_file)\n\n#         output = prediction_fn(inputs=xyz)\n#         p = output['outputs'].reshape(-1)\n\n#         valid['sign'].append(p)\n\n#         #---\n#         if t%100==0:\n#             time_taken = timer() - start_timer\n#             print('\\r %8d / %d  %s'%(t,valid_num,time_to_str(time_taken,'sec')),end='',flush=True)\n\n#     print('\\n')\n\n\n#     truth = valid_df.label.values\n#     sign  = np.stack(valid['sign'])\n#     predict = np.argsort(-sign, -1)\n#     correct = predict==truth.reshape(valid_num,1)\n#     topk = correct.cumsum(-1).mean(0)[:5]\n\n\n#     print(f'time_taken = {time_to_str(time_taken,\"sec\")}')\n#     print(f'time_taken for LB = {time_taken*1000/valid_num:05f} msec\\n')\n#     for i in range(5):\n#         print(f'topk[{i}] = {topk[i]}')  \n#     print('----- end -----\\n')","metadata":{"execution":{"iopub.status.busy":"2024-11-28T02:35:36.695103Z","iopub.execute_input":"2024-11-28T02:35:36.695351Z","iopub.status.idle":"2024-11-28T02:35:36.707533Z","shell.execute_reply.started":"2024-11-28T02:35:36.695329Z","shell.execute_reply":"2024-11-28T02:35:36.706634Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# 冠军代码但是没有数据增强和任何改进点的版本","metadata":{}},{"cell_type":"code","source":"# import tensorflow as tf\n# import numpy as np\n# import pandas as pd\n# import os\n# import json\n# from sklearn.model_selection import train_test_split\n\n# # Paths to the dataset\n# train_csv_path = \"/kaggle/input/asl-signs/train.csv\"\n# data_dir = \"/kaggle/input/asl-signs/train_landmark_files\"\n\n# # Load training metadata\n# train_df = pd.read_csv(train_csv_path)\n\n# # Load sign-to-prediction mapping\n# with open('/kaggle/input/asl-signs/sign_to_prediction_index_map.json', 'r') as f:\n#     s2p_map = json.load(f)\n# train_df['label'] = train_df['sign'].map(s2p_map.get)\n\n# # Constants\n# ROWS_PER_FRAME = 543\n# MAX_LEN = 384\n# NUM_CLASSES = 250\n# BATCH_SIZE = 32\n\n# # Load landmark data\n# def load_landmark_data(row, data_dir):\n#     pq_path = os.path.join(data_dir, row['path'].replace(\"train_landmark_files/\", \"\"))\n#     data_columns = ['x', 'y', 'z']\n#     data = pd.read_parquet(pq_path, columns=data_columns)\n#     n_frames = len(data) // ROWS_PER_FRAME\n#     data = data.values.reshape(n_frames, ROWS_PER_FRAME, len(data_columns))\n#     return data.astype(np.float32)\n\n# # Real-time data generator with padding\n# def data_generator(df, data_dir, batch_size, mode=\"train\"):\n#     preprocess_layer = Preprocess(max_len=MAX_LEN)\n#     for start in range(0, len(df), batch_size):\n#         batch_df = df.iloc[start:start + batch_size]\n#         X, y = [], []\n#         max_time_steps = 0\n        \n#         # Preprocess each sample and track max time steps\n#         for _, row in batch_df.iterrows():\n#             raw_data = load_landmark_data(row, data_dir)\n#             preprocessed_data = preprocess_layer(raw_data[None, ...]).numpy()\n#             max_time_steps = max(max_time_steps, preprocessed_data.shape[1])\n#             X.append(preprocessed_data[0])\n#             y.append(row['label'])\n\n#         # Pad all samples in the batch to the same time steps\n#         padded_X = np.zeros((len(X), max_time_steps, X[0].shape[1]), dtype=np.float32)\n#         for i, sample in enumerate(X):\n#             padded_X[i, :sample.shape[0], :] = sample\n        \n#         y = tf.keras.utils.to_categorical(y, num_classes=NUM_CLASSES)\n#         yield padded_X, y\n\n# # Top-k accuracy metric\n# def top_k_accuracy(y_true, y_pred, k=5):\n#     y_true = tf.argmax(y_true, axis=-1)\n#     y_pred = tf.argsort(y_pred, direction='DESCENDING')[:, :k]\n#     matches = tf.reduce_sum(tf.cast(tf.reduce_any(y_pred == tf.expand_dims(y_true, axis=-1), axis=-1), tf.float32))\n#     return matches / tf.cast(tf.shape(y_true)[0], tf.float32)\n\n# # Train-validation split\n# train, val = train_test_split(train_df, test_size=0.2, stratify=train_df['label'], random_state=42)\n\n# # Load the champion's model\n# model = get_model()  # Assuming champion's get_model is already defined\n# model.compile(\n#     optimizer=tf.keras.optimizers.Adam(learning_rate=1e-5),\n#     loss=tf.keras.losses.CategoricalCrossentropy(label_smoothing=0.1),\n#     metrics=['accuracy', tf.keras.metrics.TopKCategoricalAccuracy(k=5)]\n# )\n\n# # Create data generators\n# train_gen = data_generator(train, data_dir, batch_size=BATCH_SIZE, mode=\"train\")\n# val_gen = data_generator(val, data_dir, batch_size=BATCH_SIZE, mode=\"validation\")\n\n# # Train the model\n# steps_per_epoch = len(train) // BATCH_SIZE\n# validation_steps = len(val) // BATCH_SIZE\n\n# model.fit(\n#     train_gen,\n#     steps_per_epoch=steps_per_epoch,\n#     validation_data=val_gen,\n#     validation_steps=validation_steps,\n#     epochs=10\n# )\n\n# # Convert to TensorFlow Lite\n# converter = tf.lite.TFLiteConverter.from_keras_model(model)\n# converter.optimizations = [tf.lite.Optimize.DEFAULT]\n# converter.target_spec.supported_types = [tf.float16]\n# tflite_model = converter.convert()\n\n# # Save the TFLite model\n# with open('/kaggle/working/model_base.tflite', 'wb') as f:\n#     f.write(tflite_model)\n\n# print(\"Model saved successfully.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-28T02:35:36.711393Z","iopub.execute_input":"2024-11-28T02:35:36.711693Z","iopub.status.idle":"2024-11-28T02:35:36.730047Z","shell.execute_reply.started":"2024-11-28T02:35:36.711665Z","shell.execute_reply":"2024-11-28T02:35:36.729060Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# 稍微改了一下学习率","metadata":{}},{"cell_type":"code","source":"# import tensorflow as tf\n# import numpy as np\n# import pandas as pd\n# import os\n# import json\n# from sklearn.model_selection import train_test_split\n\n# # 数据集路径\n# train_csv_path = \"/kaggle/input/asl-signs/train.csv\"\n# data_dir = \"/kaggle/input/asl-signs/train_landmark_files\"\n\n# # 加载训练元数据\n# train_df = pd.read_csv(train_csv_path)\n\n# # 加载 sign-to-prediction 映射\n# with open('/kaggle/input/asl-signs/sign_to_prediction_index_map.json', 'r') as f:\n#     s2p_map = json.load(f)\n# train_df['label'] = train_df['sign'].map(s2p_map.get)\n\n# # 常量\n# ROWS_PER_FRAME = 543\n# MAX_LEN = 384\n# NUM_CLASSES = 250\n# BATCH_SIZE = 32\n\n# # 定义数据加载函数\n# def load_landmark_data(row, data_dir):\n#     pq_path = os.path.join(data_dir, row['path'].replace(\"train_landmark_files/\", \"\"))\n#     data_columns = ['x', 'y', 'z']\n#     data = pd.read_parquet(pq_path, columns=data_columns)\n#     n_frames = len(data) // ROWS_PER_FRAME\n#     data = data.values.reshape(n_frames, ROWS_PER_FRAME, len(data_columns))\n#     return data.astype(np.float32)\n\n# # 实时数据生成器（无数据增强）\n# def data_generator(df, data_dir, batch_size):\n#     preprocess_layer = Preprocess(max_len=MAX_LEN)  # 冠军模型中的预处理层\n#     for start in range(0, len(df), batch_size):\n#         batch_df = df.iloc[start:start + batch_size]\n#         X, y = [], []\n#         for _, row in batch_df.iterrows():\n#             raw_data = load_landmark_data(row, data_dir)\n#             preprocessed_data = preprocess_layer(raw_data[None, ...]).numpy()\n#             X.append(preprocessed_data[0])\n#             y.append(row['label'])\n\n#         # 零填充到固定时间步\n#         padded_X = np.zeros((len(X), MAX_LEN, X[0].shape[1]), dtype=np.float32)\n#         for i, sample in enumerate(X):\n#             padded_X[i, :sample.shape[0], :] = sample\n\n#         y = tf.keras.utils.to_categorical(y, num_classes=NUM_CLASSES)\n#         yield padded_X, y\n\n# # 分层训练验证集划分\n# train, val = train_test_split(train_df, test_size=0.2, stratify=train_df['label'], random_state=42)\n\n# # 获取冠军模型\n# model = get_model(max_len=MAX_LEN, dim=192)  # 确保冠军的 get_model 已定义\n# model.compile(\n#     optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),\n#     loss=tf.keras.losses.CategoricalCrossentropy(label_smoothing=0.1),\n#     metrics=['accuracy', tf.keras.metrics.TopKCategoricalAccuracy(k=5)]\n# )\n\n# # 创建数据生成器\n# train_gen = data_generator(train, data_dir, batch_size=BATCH_SIZE)\n# val_gen = data_generator(val, data_dir, batch_size=BATCH_SIZE)\n\n# # 训练参数\n# steps_per_epoch = len(train) // BATCH_SIZE\n# validation_steps = len(val) // BATCH_SIZE\n\n# # 模型训练\n# history = model.fit(\n#     train_gen,\n#     steps_per_epoch=steps_per_epoch,\n#     validation_data=val_gen,\n#     validation_steps=validation_steps,\n#     epochs=10\n# )\n\n# # 模型保存为 TensorFlow Lite\n# converter = tf.lite.TFLiteConverter.from_keras_model(model)\n# converter.optimizations = [tf.lite.Optimize.DEFAULT]\n# converter.target_spec.supported_types = [tf.float16]\n# tflite_model = converter.convert()\n\n# with open('/kaggle/working/model_base.tflite', 'wb') as f:\n#     f.write(tflite_model)\n\n# print(\"Model training and saving completed.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-28T02:35:36.731200Z","iopub.execute_input":"2024-11-28T02:35:36.731455Z","iopub.status.idle":"2024-11-28T02:35:36.747064Z","shell.execute_reply.started":"2024-11-28T02:35:36.731431Z","shell.execute_reply":"2024-11-28T02:35:36.746328Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# 加大batchsize到64","metadata":{}},{"cell_type":"code","source":"# import tensorflow as tf\n# import numpy as np\n# import pandas as pd\n# import os\n# import json\n# from sklearn.model_selection import train_test_split\n\n# # 数据集路径\n# train_csv_path = \"/kaggle/input/asl-signs/train.csv\"\n# data_dir = \"/kaggle/input/asl-signs/train_landmark_files\"\n\n# # 加载训练元数据\n# train_df = pd.read_csv(train_csv_path)\n\n# # 加载 sign-to-prediction 映射\n# with open('/kaggle/input/asl-signs/sign_to_prediction_index_map.json', 'r') as f:\n#     s2p_map = json.load(f)\n# train_df['label'] = train_df['sign'].map(s2p_map.get)\n\n# # 常量\n# ROWS_PER_FRAME = 543\n# MAX_LEN = 384\n# NUM_CLASSES = 250\n# BATCH_SIZE = 64  # 增加的 Batch Size\n\n# # 定义数据加载函数\n# def load_landmark_data(row, data_dir):\n#     pq_path = os.path.join(data_dir, row['path'].replace(\"train_landmark_files/\", \"\"))\n#     data_columns = ['x', 'y', 'z']\n#     data = pd.read_parquet(pq_path, columns=data_columns)\n#     n_frames = len(data) // ROWS_PER_FRAME\n#     data = data.values.reshape(n_frames, ROWS_PER_FRAME, len(data_columns))\n#     return data.astype(np.float32)\n\n# # 实时数据生成器（无数据增强）\n# def data_generator(df, data_dir, batch_size):\n#     preprocess_layer = Preprocess(max_len=MAX_LEN)  # 冠军模型中的预处理层\n#     for start in range(0, len(df), batch_size):\n#         batch_df = df.iloc[start:start + batch_size]\n#         X, y = [], []\n#         for _, row in batch_df.iterrows():\n#             raw_data = load_landmark_data(row, data_dir)\n#             preprocessed_data = preprocess_layer(raw_data[None, ...]).numpy()\n#             X.append(preprocessed_data[0])\n#             y.append(row['label'])\n\n#         # 零填充到固定时间步\n#         padded_X = np.zeros((len(X), MAX_LEN, X[0].shape[1]), dtype=np.float32)\n#         for i, sample in enumerate(X):\n#             padded_X[i, :sample.shape[0], :] = sample\n\n#         y = tf.keras.utils.to_categorical(y, num_classes=NUM_CLASSES)\n#         yield padded_X, y\n\n# # 分层训练验证集划分\n# train, val = train_test_split(train_df, test_size=0.2, stratify=train_df['label'], random_state=42)\n\n# # 获取冠军模型\n# model = get_model(max_len=MAX_LEN, dim=192)  # 确保冠军的 get_model 已定义\n# model.compile(\n#     optimizer=tf.keras.optimizers.Adam(learning_rate=2e-4),  # 调整学习率以匹配更大的 batch size\n#     loss=tf.keras.losses.CategoricalCrossentropy(label_smoothing=0.1),\n#     metrics=['accuracy', tf.keras.metrics.TopKCategoricalAccuracy(k=5)]\n# )\n\n# # 创建数据生成器\n# train_gen = data_generator(train, data_dir, batch_size=BATCH_SIZE)\n# val_gen = data_generator(val, data_dir, batch_size=BATCH_SIZE)\n\n# # 训练参数（自动适配未整除部分）\n# steps_per_epoch = (len(train) + BATCH_SIZE - 1) // BATCH_SIZE\n# validation_steps = (len(val) + BATCH_SIZE - 1) // BATCH_SIZE\n\n# # 模型训练\n# history = model.fit(\n#     train_gen,\n#     steps_per_epoch=steps_per_epoch,\n#     validation_data=val_gen,\n#     validation_steps=validation_steps,\n#     epochs=10\n# )\n\n# # 模型保存为 TensorFlow Lite\n# converter = tf.lite.TFLiteConverter.from_keras_model(model)\n# converter.optimizations = [tf.lite.Optimize.DEFAULT]\n# converter.target_spec.supported_types = [tf.float16]\n# tflite_model = converter.convert()\n\n# with open('/kaggle/working/model_base.tflite', 'wb') as f:\n#     f.write(tflite_model)\n\n# print(\"Model training and saving completed.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-28T02:35:36.748375Z","iopub.execute_input":"2024-11-28T02:35:36.748707Z","iopub.status.idle":"2024-11-28T02:35:36.763526Z","shell.execute_reply.started":"2024-11-28T02:35:36.748682Z","shell.execute_reply":"2024-11-28T02:35:36.762847Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# 加大batch size到128","metadata":{}},{"cell_type":"code","source":"# import tensorflow as tf\n# import numpy as np\n# import pandas as pd\n# import os\n# import json\n# from sklearn.model_selection import train_test_split\n\n# # 混合精度训练，减少显存占用\n# from tensorflow.keras import mixed_precision\n# policy = mixed_precision.Policy('mixed_float16')  # 使用正式的 API\n# mixed_precision.set_global_policy(policy)\n\n# # 数据集路径\n# train_csv_path = \"/kaggle/input/asl-signs/train.csv\"\n# data_dir = \"/kaggle/input/asl-signs/train_landmark_files\"\n\n# # 加载训练元数据\n# train_df = pd.read_csv(train_csv_path)\n\n# # 加载 sign-to-prediction 映射\n# with open('/kaggle/input/asl-signs/sign_to_prediction_index_map.json', 'r') as f:\n#     s2p_map = json.load(f)\n# train_df['label'] = train_df['sign'].map(s2p_map.get)\n\n# # 常量\n# ROWS_PER_FRAME = 543\n# MAX_LEN = 384\n# NUM_CLASSES = 250\n# BATCH_SIZE = 128  # 增大 Batch Size\n\n# # 定义数据加载函数\n# def load_landmark_data(row, data_dir):\n#     pq_path = os.path.join(data_dir, row['path'].replace(\"train_landmark_files/\", \"\"))\n#     data_columns = ['x', 'y', 'z']\n#     data = pd.read_parquet(pq_path, columns=data_columns)\n#     n_frames = len(data) // ROWS_PER_FRAME\n#     data = data.values.reshape(n_frames, ROWS_PER_FRAME, len(data_columns))\n#     return data.astype(np.float32)\n\n# # 实时数据生成器（无数据增强）\n# def data_generator(df, data_dir, batch_size):\n#     preprocess_layer = Preprocess(max_len=MAX_LEN)  # 冠军模型中的预处理层\n#     for start in range(0, len(df), batch_size):\n#         batch_df = df.iloc[start:start + batch_size]\n#         X, y = [], []\n#         for _, row in batch_df.iterrows():\n#             raw_data = load_landmark_data(row, data_dir)\n#             preprocessed_data = preprocess_layer(raw_data[None, ...]).numpy()\n#             X.append(preprocessed_data[0])\n#             y.append(row['label'])\n\n#         # 零填充到固定时间步\n#         padded_X = np.zeros((len(X), MAX_LEN, X[0].shape[1]), dtype=np.float32)\n#         for i, sample in enumerate(X):\n#             padded_X[i, :sample.shape[0], :] = sample\n\n#         y = tf.keras.utils.to_categorical(y, num_classes=NUM_CLASSES)\n#         yield padded_X, y\n\n# # 分层训练验证集划分\n# train, val = train_test_split(train_df, test_size=0.2, stratify=train_df['label'], random_state=42)\n\n# # 获取冠军模型\n# model = get_model()  # 保持冠军模型架构不变\n\n# # 根据 Batch Size 调整学习率\n# initial_learning_rate = 2e-4\n# adjusted_learning_rate = initial_learning_rate * (BATCH_SIZE / 64)  # 线性调整学习率\n# model.compile(\n#     optimizer=tf.keras.optimizers.Adam(learning_rate=adjusted_learning_rate),\n#     loss=tf.keras.losses.CategoricalCrossentropy(label_smoothing=0.1),\n#     metrics=['accuracy', tf.keras.metrics.TopKCategoricalAccuracy(k=5)]\n# )\n\n# # 创建数据生成器\n# train_gen = data_generator(train, data_dir, batch_size=BATCH_SIZE)\n# val_gen = data_generator(val, data_dir, batch_size=BATCH_SIZE)\n\n# # 动态调整训练参数\n# steps_per_epoch = (len(train) + BATCH_SIZE - 1) // BATCH_SIZE\n# validation_steps = (len(val) + BATCH_SIZE - 1) // BATCH_SIZE\n\n# # 模型训练\n# history = model.fit(\n#     train_gen,\n#     steps_per_epoch=steps_per_epoch,\n#     validation_data=val_gen,\n#     validation_steps=validation_steps,\n#     epochs=10\n# )\n\n# # 模型保存为 TensorFlow Lite\n# converter = tf.lite.TFLiteConverter.from_keras_model(model)\n# converter.optimizations = [tf.lite.Optimize.DEFAULT]\n# converter.target_spec.supported_types = [tf.float16]\n# tflite_model = converter.convert()\n\n# with open('/kaggle/working/model_base.tflite', 'wb') as f:\n#     f.write(tflite_model)\n\n# print(\"Model training and saving completed.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-28T02:35:36.764697Z","iopub.execute_input":"2024-11-28T02:35:36.764944Z","iopub.status.idle":"2024-11-28T02:35:36.780460Z","shell.execute_reply.started":"2024-11-28T02:35:36.764922Z","shell.execute_reply":"2024-11-28T02:35:36.779810Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# 冠军代码融入一些改进点","metadata":{}},{"cell_type":"code","source":"# import tensorflow as tf\n\n# # Import other libraries and define constants AFTER GPU configuration\n# import numpy as np\n# import pandas as pd\n# import os\n# import json\n# from sklearn.model_selection import train_test_split\n# from tensorflow.keras.callbacks import ReduceLROnPlateau, ModelCheckpoint\n\n# # Paths to the dataset\n# train_csv_path = \"/kaggle/input/asl-signs/train.csv\"\n# data_dir = \"/kaggle/input/asl-signs/train_landmark_files\"\n\n# # Load training metadata\n# train_df = pd.read_csv(train_csv_path)\n\n# # Load sign-to-prediction mapping\n# with open('/kaggle/input/asl-signs/sign_to_prediction_index_map.json', 'r') as f:\n#     s2p_map = json.load(f)\n# train_df['label'] = train_df['sign'].map(s2p_map.get)\n\n# # Constants\n# ROWS_PER_FRAME = 543\n# MAX_LEN = 384\n# NUM_CLASSES = 250\n# BASE_BATCH_SIZE = 32\n\n# # Load landmark data\n# def load_landmark_data(row, data_dir):\n#     pq_path = os.path.join(data_dir, row['path'].replace(\"train_landmark_files/\", \"\"))\n#     data_columns = ['x', 'y', 'z']\n#     data = pd.read_parquet(pq_path, columns=data_columns)\n#     n_frames = len(data) // ROWS_PER_FRAME\n#     data = data.values.reshape(n_frames, ROWS_PER_FRAME, len(data_columns))\n#     return data.astype(np.float32)\n\n# # Data generator\n# def data_generator(df, data_dir, base_batch_size):\n#     preprocess_layer = Preprocess(max_len=MAX_LEN)\n#     for start in range(0, len(df), base_batch_size):\n#         batch_df = df.iloc[start:start + base_batch_size]\n#         X, y = [], []\n#         for _, row in batch_df.iterrows():\n#             raw_data = load_landmark_data(row, data_dir)\n#             preprocessed_data = preprocess_layer(raw_data[None, ...]).numpy()\n#             X.append(preprocessed_data[0])\n#             y.append(row['label'])\n#         X = tf.keras.preprocessing.sequence.pad_sequences(X, maxlen=MAX_LEN, dtype='float32', padding='post')\n#         y = tf.keras.utils.to_categorical(y, num_classes=NUM_CLASSES)\n#         yield np.array(X), np.array(y)\n\n# # Train-validation split\n# train, val = train_test_split(train_df, test_size=0.2, stratify=train_df['label'], random_state=42)\n\n# # Load the champion's model\n# model = get_model()\n# model.compile(\n#     optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),\n#     loss=tf.keras.losses.CategoricalCrossentropy(label_smoothing=0.1),\n#     metrics=['accuracy', tf.keras.metrics.TopKCategoricalAccuracy(k=5)]\n# )\n\n# # Learning rate scheduler and checkpoints\n# lr_scheduler = ReduceLROnPlateau(monitor='val_accuracy', factor=0.5, patience=3, verbose=1, min_lr=1e-6)\n# model_checkpoint = ModelCheckpoint(\n#     '/kaggle/working/best_model_no_augment.h5', monitor='val_accuracy', save_best_only=True, verbose=1\n# )\n\n# # Create data generators\n# train_gen = data_generator(train, data_dir, base_batch_size=BASE_BATCH_SIZE)\n# val_gen = data_generator(val, data_dir, base_batch_size=BASE_BATCH_SIZE)\n\n# # Train the model\n# steps_per_epoch = len(train) // BASE_BATCH_SIZE\n# validation_steps = len(val) // BASE_BATCH_SIZE\n\n# model.fit(\n#     train_gen,\n#     steps_per_epoch=steps_per_epoch,\n#     validation_data=val_gen,\n#     validation_steps=validation_steps,\n#     epochs=10,\n#     callbacks=[lr_scheduler, model_checkpoint]\n# )\n\n# # Convert to TensorFlow Lite\n# converter = tf.lite.TFLiteConverter.from_keras_model(model)\n# converter.optimizations = [tf.lite.Optimize.DEFAULT]\n# converter.target_spec.supported_types = [tf.float16]\n# tflite_model = converter.convert()\n\n# # Save the TFLite model\n# with open('/kaggle/working/model_no_augment.tflite', 'wb') as f:\n#     f.write(tflite_model)\n\n# print(\"Model training and conversion complete.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-28T02:35:36.781591Z","iopub.execute_input":"2024-11-28T02:35:36.781871Z","iopub.status.idle":"2024-11-28T02:35:36.800416Z","shell.execute_reply.started":"2024-11-28T02:35:36.781844Z","shell.execute_reply":"2024-11-28T02:35:36.799589Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# 冠军代码，但是融入了很简单的高斯噪音数据增强和其他的改进点","metadata":{}},{"cell_type":"code","source":"# import tensorflow as tf\n\n# # Import other libraries and define constants AFTER GPU configuration\n# import numpy as np\n# import pandas as pd\n# import os\n# import json\n# from sklearn.model_selection import train_test_split\n# from tensorflow.keras.callbacks import ReduceLROnPlateau, ModelCheckpoint\n\n# # Paths to the dataset\n# train_csv_path = \"/kaggle/input/asl-signs/train.csv\"\n# data_dir = \"/kaggle/input/asl-signs/train_landmark_files\"\n\n# # Load training metadata\n# train_df = pd.read_csv(train_csv_path)\n\n# # Load sign-to-prediction mapping\n# with open('/kaggle/input/asl-signs/sign_to_prediction_index_map.json', 'r') as f:\n#     s2p_map = json.load(f)\n# train_df['label'] = train_df['sign'].map(s2p_map.get)\n\n# # Constants\n# ROWS_PER_FRAME = 543\n# MAX_LEN = 384\n# NUM_CLASSES = 250\n# BASE_BATCH_SIZE = 32\n\n# # Load landmark data\n# def load_landmark_data(row, data_dir):\n#     pq_path = os.path.join(data_dir, row['path'].replace(\"train_landmark_files/\", \"\"))\n#     data_columns = ['x', 'y', 'z']\n#     data = pd.read_parquet(pq_path, columns=data_columns)\n#     n_frames = len(data) // ROWS_PER_FRAME\n#     data = data.values.reshape(n_frames, ROWS_PER_FRAME, len(data_columns))\n#     return data.astype(np.float32)\n\n# # Data augmentation\n# def augment_data(data):\n#     noise = np.random.normal(0, 0.01, data.shape)\n#     data += noise\n#     return np.clip(data, -1.0, 1.0)\n\n# # Data generator\n# def data_generator(df, data_dir, base_batch_size):\n#     preprocess_layer = Preprocess(max_len=MAX_LEN)\n#     for start in range(0, len(df), base_batch_size):\n#         batch_df = df.iloc[start:start + base_batch_size]\n#         X, y = [], []\n#         for _, row in batch_df.iterrows():\n#             raw_data = load_landmark_data(row, data_dir)\n#             raw_data = augment_data(raw_data)\n#             preprocessed_data = preprocess_layer(raw_data[None, ...]).numpy()\n#             X.append(preprocessed_data[0])\n#             y.append(row['label'])\n#         X = tf.keras.preprocessing.sequence.pad_sequences(X, maxlen=MAX_LEN, dtype='float32', padding='post')\n#         y = tf.keras.utils.to_categorical(y, num_classes=NUM_CLASSES)\n#         yield np.array(X), np.array(y)\n\n# # Train-validation split\n# train, val = train_test_split(train_df, test_size=0.2, stratify=train_df['label'], random_state=42)\n\n# # Load the champion's model\n# model = get_model()\n# model.compile(\n#     optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),\n#     loss=tf.keras.losses.CategoricalCrossentropy(label_smoothing=0.1),\n#     metrics=['accuracy', tf.keras.metrics.TopKCategoricalAccuracy(k=5)]\n# )\n\n# # Learning rate scheduler and checkpoints\n# lr_scheduler = ReduceLROnPlateau(monitor='val_accuracy', factor=0.5, patience=3, verbose=1, min_lr=1e-6)\n# model_checkpoint = ModelCheckpoint(\n#     '/kaggle/working/best_model_with_augment.h5', monitor='val_accuracy', save_best_only=True, verbose=1\n# )\n\n# # Create data generators\n# train_gen = data_generator(train, data_dir, base_batch_size=BASE_BATCH_SIZE)\n# val_gen = data_generator(val, data_dir, base_batch_size=BASE_BATCH_SIZE)\n\n# # Train the model\n# steps_per_epoch = len(train) // BASE_BATCH_SIZE\n# validation_steps = len(val) // BASE_BATCH_SIZE\n\n# model.fit(\n#     train_gen,\n#     steps_per_epoch=steps_per_epoch,\n#     validation_data=val_gen,\n#     validation_steps=validation_steps,\n#     epochs=10,\n#     # verbose=1,  # 设置为 1，显示每个 epoch 的详细日志\n#     callbacks=[lr_scheduler, model_checkpoint]\n# )\n\n# # Convert to TensorFlow Lite\n# converter = tf.lite.TFLiteConverter.from_keras_model(model)\n# converter.optimizations = [tf.lite.Optimize.DEFAULT]\n# converter.target_spec.supported_types = [tf.float16]\n# tflite_model = converter.convert()\n\n# # Save the TFLite model\n# with open('/kaggle/working/model_with_augment.tflite', 'wb') as f:\n#     f.write(tflite_model)\n\n# print(\"Model training and conversion complete.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-28T02:35:36.801391Z","iopub.execute_input":"2024-11-28T02:35:36.801686Z","iopub.status.idle":"2024-11-28T02:35:36.819792Z","shell.execute_reply.started":"2024-11-28T02:35:36.801631Z","shell.execute_reply":"2024-11-28T02:35:36.819171Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# 第五名的复现","metadata":{}},{"cell_type":"code","source":"# import tensorflow as tf\n# import numpy as np\n# import pandas as pd\n# import os\n# import json\n# from sklearn.model_selection import train_test_split\n\n# # Constants\n# MAX_LEN = 256\n# NUM_CLASSES = 250\n# EMBED_DIM = 480\n# NUM_HEADS = 16\n# NUM_BLOCKS = 3\n# BATCH_SIZE = 8\n# GRAD_ACCUM_STEPS = 4\n# LEARNING_RATE = 1e-4\n# EPOCHS = 10\n# PREFETCH_SIZE = tf.data.AUTOTUNE\n\n# # Data paths\n# TRAIN_CSV_PATH = '/kaggle/input/asl-signs/train.csv'\n# DATA_DIR = '/kaggle/input/asl-signs/train_landmark_files'\n# SIGN_TO_LABEL_PATH = '/kaggle/input/asl-signs/sign_to_prediction_index_map.json'\n\n# # GPU memory growth\n# gpus = tf.config.list_physical_devices('GPU')\n# for gpu in gpus:\n#     tf.config.experimental.set_memory_growth(gpu, True)\n\n# # Positional Encoding\n# def positional_encoding(length, embed_dim):\n#     position = np.arange(length)[:, np.newaxis]\n#     div_term = np.exp(np.arange(0, embed_dim, 2) * -(np.log(10000.0) / embed_dim))\n#     pos_enc = np.zeros((length, embed_dim))\n#     pos_enc[:, 0::2] = np.sin(position * div_term)\n#     pos_enc[:, 1::2] = np.cos(position * div_term)\n#     return tf.constant(pos_enc, dtype=tf.float32)\n\n# # Input Network\n# class InputNet(tf.keras.layers.Layer):\n#     def __init__(self):\n#         super(InputNet, self).__init__()\n#         self.max_length = MAX_LEN\n\n#     def call(self, xyz):\n#         xyz = xyz[:, :, :2]\n#         L = tf.shape(xyz)[1]\n#         if L > self.max_length:\n#             xyz = xyz[:, L//2 - self.max_length//2: L//2 + self.max_length//2, :]\n#         xyz = tf.where(tf.math.is_nan(xyz), tf.zeros_like(xyz), xyz)\n#         mean = tf.reduce_mean(xyz, axis=[1, 2], keepdims=True)\n#         std = tf.math.reduce_std(xyz, axis=[1, 2], keepdims=True) + 1e-6\n#         xyz = (xyz - mean) / std\n#         return xyz\n\n# # Transformer Block\n# class TransformerBlock(tf.keras.layers.Layer):\n#     def __init__(self, embed_dim, num_heads):\n#         super(TransformerBlock, self).__init__()\n#         self.attention = tf.keras.layers.MultiHeadAttention(num_heads=num_heads, key_dim=embed_dim)\n#         self.ffn = tf.keras.Sequential([\n#             tf.keras.layers.Dense(embed_dim * 4, activation='relu'),\n#             tf.keras.layers.Dense(embed_dim)\n#         ])\n#         self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n#         self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n\n#     def call(self, inputs, training=False):\n#         attn_output = self.attention(inputs, inputs)\n#         out1 = self.layernorm1(inputs + attn_output)\n#         ffn_output = self.ffn(out1)\n#         return self.layernorm2(out1 + ffn_output)\n\n# # Model\n# class ASLTransformer(tf.keras.Model):\n#     def __init__(self):\n#         super(ASLTransformer, self).__init__()\n#         self.input_net = InputNet()\n#         self.embedding = tf.keras.layers.Dense(EMBED_DIM)\n#         self.positional_encoding = positional_encoding(MAX_LEN, EMBED_DIM)\n#         self.transformer_blocks = [TransformerBlock(EMBED_DIM, NUM_HEADS) for _ in range(NUM_BLOCKS)]\n#         self.global_avg_pool = tf.keras.layers.GlobalAveragePooling1D()\n#         self.output_layer = tf.keras.layers.Dense(NUM_CLASSES, activation='softmax')\n\n#     def call(self, inputs, training=False):\n#         x = tf.reshape(inputs, [-1, MAX_LEN, 543 * 3])  # 展平关键点\n#         x = self.input_net(x)\n#         x = self.embedding(x)\n#         x += self.positional_encoding[:tf.shape(x)[1], :]\n#         for block in self.transformer_blocks:\n#             x = block(x, training)\n#         x = self.global_avg_pool(x)\n#         return self.output_layer(x)\n\n# # Data Generator\n# def preprocess(row, data_dir):\n#     pq_path = os.path.join(data_dir, row['path'].replace(\"train_landmark_files/\", \"\"))\n#     data = pd.read_parquet(pq_path, columns=['x', 'y', 'z']).values\n#     n_frames = len(data) // 543\n#     data = data.reshape(n_frames, 543, 3)\n\n#     # Normalize\n#     data = (data - np.nanmean(data, axis=(0, 1))) / (np.nanstd(data, axis=(0, 1)) + 1e-6)\n#     data[np.isnan(data)] = 0\n\n#     # Padding or truncation\n#     if len(data) > MAX_LEN:\n#         data = data[:MAX_LEN]\n#     else:\n#         pad_size = MAX_LEN - len(data)\n#         data = np.vstack([data, np.zeros((pad_size, 543, 3))])\n#     return data.astype(np.float32)\n\n# def data_generator(df, data_dir):\n#     for _, row in df.iterrows():\n#         data = preprocess(row, data_dir)\n#         label = row['label']\n#         yield data, label\n\n# def create_tf_dataset(df, data_dir, batch_size):\n#     dataset = tf.data.Dataset.from_generator(\n#         lambda: data_generator(df, data_dir),\n#         output_signature=(\n#             tf.TensorSpec(shape=(MAX_LEN, 543, 3), dtype=tf.float32),\n#             tf.TensorSpec(shape=(), dtype=tf.int32)\n#         )\n#     )\n#     dataset = dataset.shuffle(1000).batch(batch_size).prefetch(PREFETCH_SIZE)\n#     return dataset\n\n# # Gradient Accumulation\n# class GradientAccumulation(tf.keras.callbacks.Callback):\n#     def __init__(self, accum_steps):\n#         self.accum_steps = accum_steps\n#         self.accum_gradients = None\n\n#     def on_train_batch_begin(self, batch, logs=None):\n#         if self.accum_gradients is None:\n#             self.accum_gradients = [tf.zeros_like(var) for var in self.model.trainable_variables]\n\n#     def on_train_batch_end(self, batch, logs=None):\n#         for i, gradient in enumerate(self.accum_gradients):\n#             self.accum_gradients[i] += gradient / self.accum_steps\n\n# # Training\n# def train_model():\n#     train_df = pd.read_csv(TRAIN_CSV_PATH)\n#     with open(SIGN_TO_LABEL_PATH, 'r') as f:\n#         sign_to_label = json.load(f)\n#     train_df['label'] = train_df['sign'].map(sign_to_label.get)\n#     train_df, val_df = train_test_split(train_df, test_size=0.2, stratify=train_df['label'], random_state=42)\n\n#     train_dataset = create_tf_dataset(train_df, DATA_DIR, BATCH_SIZE)\n#     val_dataset = create_tf_dataset(val_df, DATA_DIR, BATCH_SIZE)\n\n#     strategy = tf.distribute.MirroredStrategy()\n#     with strategy.scope():\n#         model = ASLTransformer()\n#         model.compile(optimizer=tf.keras.optimizers.Adam(LEARNING_RATE),\n#                       loss='sparse_categorical_crossentropy',\n#                       metrics=['accuracy'])\n#         model.build(input_shape=(None, MAX_LEN, 543 * 3))  # 初始化权重\n\n#     history = model.fit(\n#         train_dataset,\n#         validation_data=val_dataset,\n#         epochs=EPOCHS,\n#         verbose=1,\n#         callbacks=[GradientAccumulation(GRAD_ACCUM_STEPS)]\n#     )\n\n#     return model, history\n\n# # Main\n# if __name__ == \"__main__\":\n#     model, history = train_model()\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-28T02:35:36.821244Z","iopub.execute_input":"2024-11-28T02:35:36.821558Z","iopub.status.idle":"2024-11-28T02:35:36.840325Z","shell.execute_reply.started":"2024-11-28T02:35:36.821526Z","shell.execute_reply":"2024-11-28T02:35:36.839497Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import tensorflow as tf\nimport numpy as np\nimport pandas as pd\nimport os\nimport json\nfrom sklearn.model_selection import train_test_split\n\n# Constants\nMAX_LEN = 384  # 保持原有序列长度\nNUM_CLASSES = 250\nEMBED_DIM = 480  # 保持高维度\nNUM_HEADS = 16\nNUM_BLOCKS = 3  # 保持 Transformer 层数\nBATCH_SIZE = 16  # 降低批量大小以适配显存\nLEARNING_RATE = 1e-4\nEPOCHS = 10\nPREFETCH_SIZE = tf.data.AUTOTUNE\n\n# Data paths\nTRAIN_CSV_PATH = '/kaggle/input/asl-signs/train.csv'\nDATA_DIR = '/kaggle/input/asl-signs/train_landmark_files'\nSIGN_TO_LABEL_PATH = '/kaggle/input/asl-signs/sign_to_prediction_index_map.json'\n\n# GPU memory growth\ngpus = tf.config.list_physical_devices('GPU')\nfor gpu in gpus:\n    tf.config.experimental.set_memory_growth(gpu, True)\n\n# Positional Encoding\ndef positional_encoding(length, embed_dim):\n    position = np.arange(length)[:, np.newaxis]\n    div_term = np.exp(np.arange(0, embed_dim, 2) * -(np.log(10000.0) / embed_dim))\n    pos_enc = np.zeros((length, embed_dim))\n    pos_enc[:, 0::2] = np.sin(position * div_term)\n    pos_enc[:, 1::2] = np.cos(position * div_term)\n    return tf.constant(pos_enc, dtype=tf.float32)\n\n# Input Network\nclass InputNet(tf.keras.layers.Layer):\n    def __init__(self):\n        super(InputNet, self).__init__()\n        self.max_length = MAX_LEN\n\n    def call(self, xyz):\n        xyz = xyz[:, :, :2]  # 仅保留 x 和 y 坐标\n        L = tf.shape(xyz)[1]\n        if L > self.max_length:\n            xyz = xyz[:, L//2 - self.max_length//2: L//2 + self.max_length//2, :]\n        xyz = tf.where(tf.math.is_nan(xyz), tf.zeros_like(xyz), xyz)\n        mean = tf.reduce_mean(xyz, axis=[1, 2], keepdims=True)\n        std = tf.math.reduce_std(xyz, axis=[1, 2], keepdims=True) + 1e-6\n        xyz = (xyz - mean) / std\n        return xyz\n\n# Transformer Block\nclass TransformerBlock(tf.keras.layers.Layer):\n    def __init__(self, embed_dim, num_heads):\n        super(TransformerBlock, self).__init__()\n        self.attention = tf.keras.layers.MultiHeadAttention(num_heads=num_heads, key_dim=embed_dim)\n        self.ffn = tf.keras.Sequential([\n            tf.keras.layers.Dense(embed_dim * 4, activation='relu'),\n            tf.keras.layers.Dense(embed_dim)\n        ])\n        self.layernorm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n        self.layernorm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)\n\n    def call(self, inputs, training=False):\n        attn_output = self.attention(inputs, inputs)\n        out1 = self.layernorm1(inputs + attn_output)\n        ffn_output = self.ffn(out1)\n        return self.layernorm2(out1 + ffn_output)\n\n# Model\nclass ASLTransformer(tf.keras.Model):\n    def __init__(self):\n        super(ASLTransformer, self).__init__()\n        self.input_net = InputNet()\n        self.embedding = tf.keras.layers.Dense(EMBED_DIM)\n        self.positional_encoding = positional_encoding(MAX_LEN, EMBED_DIM)\n        self.transformer_blocks = [TransformerBlock(EMBED_DIM, NUM_HEADS) for _ in range(NUM_BLOCKS)]\n        self.global_avg_pool = tf.keras.layers.GlobalAveragePooling1D()\n        self.output_layer = tf.keras.layers.Dense(NUM_CLASSES, activation='softmax')\n\n    def call(self, inputs, training=False):\n        x = tf.reshape(inputs, [-1, MAX_LEN, 543 * 3])  # 展平关键点\n        x = self.input_net(x)\n        x = self.embedding(x)\n        x += self.positional_encoding[:tf.shape(x)[1], :]\n        for block in self.transformer_blocks:\n            x = block(x, training)\n        x = self.global_avg_pool(x)\n        return self.output_layer(x)\n\n# Data Generator\ndef preprocess(row, data_dir):\n    pq_path = os.path.join(data_dir, row['path'].replace(\"train_landmark_files/\", \"\"))\n    data = pd.read_parquet(pq_path, columns=['x', 'y', 'z']).values\n    n_frames = len(data) // 543\n    data = data.reshape(n_frames, 543, 3)\n\n    # Normalize\n    data = (data - np.nanmean(data, axis=(0, 1))) / (np.nanstd(data, axis=(0, 1)) + 1e-6)\n    data[np.isnan(data)] = 0\n\n    # Padding or truncation\n    if len(data) > MAX_LEN:\n        data = data[:MAX_LEN]\n    else:\n        pad_size = MAX_LEN - len(data)\n        data = np.vstack([data, np.zeros((pad_size, 543, 3))])\n    return data.astype(np.float32)\n\ndef data_generator(df, data_dir):\n    for _, row in df.iterrows():\n        data = preprocess(row, data_dir)\n        label = row['label']\n        yield data, label\n\ndef create_tf_dataset(df, data_dir, batch_size):\n    dataset = tf.data.Dataset.from_generator(\n        lambda: data_generator(df, data_dir),\n        output_signature=(\n            tf.TensorSpec(shape=(MAX_LEN, 543, 3), dtype=tf.float32),\n            tf.TensorSpec(shape=(), dtype=tf.int32)\n        )\n    )\n    dataset = dataset.shuffle(1000).batch(batch_size).prefetch(PREFETCH_SIZE)\n    return dataset\n\n# Training\ndef train_model():\n    train_df = pd.read_csv(TRAIN_CSV_PATH)\n    with open(SIGN_TO_LABEL_PATH, 'r') as f:\n        sign_to_label = json.load(f)\n    train_df['label'] = train_df['sign'].map(sign_to_label.get)\n    train_df, val_df = train_test_split(train_df, test_size=0.2, stratify=train_df['label'], random_state=42)\n\n    train_dataset = create_tf_dataset(train_df, DATA_DIR, BATCH_SIZE)\n    val_dataset = create_tf_dataset(val_df, DATA_DIR, BATCH_SIZE)\n\n    strategy = tf.distribute.MirroredStrategy()\n    with strategy.scope():\n        model = ASLTransformer()\n        model.compile(\n            optimizer=tf.keras.optimizers.Adam(LEARNING_RATE),\n            loss='sparse_categorical_crossentropy',\n            metrics=[\n                tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy'),\n                tf.keras.metrics.SparseTopKCategoricalAccuracy(k=5, name='top_k_accuracy')\n            ]\n        )\n\n    history = model.fit(\n        train_dataset,\n        validation_data=val_dataset,\n        epochs=EPOCHS,\n        verbose=1\n    )\n\n    return model, history\n\n# Main\nif __name__ == \"__main__\":\n    model, history = train_model()\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2024-11-28T02:35:36.841575Z","iopub.execute_input":"2024-11-28T02:35:36.842050Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null}]}