{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":56537,"databundleVersionId":8877088,"sourceType":"competition"},{"sourceId":8409068,"sourceType":"datasetVersion","datasetId":5004471},{"sourceId":8901446,"sourceType":"datasetVersion","datasetId":5351317}],"dockerImageVersionId":30699,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"The overall architecture is copied from the code in this Kaggle notebook.\nhttps://www.kaggle.com/code/abiolatti/keras-baseline-seq2seq?scriptVersionId=180403717\n\n\nThe model architecture is based on the paper discussed in this Kaggle discussion and is detailed in this arXiv paper.\n\nhttps://www.kaggle.com/competitions/leap-atmospheric-physics-ai-climsim/discussion/516605\nhttps://arxiv.org/abs/2407.00124\n\nI trained the model for 22 epochs. It achieved its highest performance at epoch 20 but showed signs of overfitting afterward.","metadata":{}},{"cell_type":"code","source":"import os\nos.environ[\"KERAS_BACKEND\"] = \"jax\"\n\nimport gc\nimport numpy as np\nimport pandas as pd\nimport polars as pl\nimport matplotlib.pyplot as plt\n \nfrom keras.regularizers import l2\n\nimport tensorflow as tf\nimport jax\nimport keras\nfrom keras.layers import Conv1D, GroupNormalization, Activation\n\nfrom sklearn import metrics\n\nfrom tqdm.notebook import tqdm\n\nprint(tf.__version__)\nprint(jax.__version__)","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:07:06.663166Z","iopub.execute_input":"2024-07-08T02:07:06.663999Z","iopub.status.idle":"2024-07-08T02:07:20.234405Z","shell.execute_reply.started":"2024-07-08T02:07:06.66397Z","shell.execute_reply":"2024-07-08T02:07:20.23348Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def is_interactive():\n    return 'runtime' in get_ipython().config.IPKernelApp.connection_file\n\nprint('Interactive?', is_interactive())","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:07:20.236123Z","iopub.execute_input":"2024-07-08T02:07:20.236626Z","iopub.status.idle":"2024-07-08T02:07:20.241642Z","shell.execute_reply.started":"2024-07-08T02:07:20.236599Z","shell.execute_reply":"2024-07-08T02:07:20.240795Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"isTrain = False\nSEED = 5467856\nkeras.utils.set_random_seed(SEED)\ntf.random.set_seed(SEED)\ntf.config.experimental.enable_op_determinism()","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:07:20.242627Z","iopub.execute_input":"2024-07-08T02:07:20.242872Z","iopub.status.idle":"2024-07-08T02:07:20.270716Z","shell.execute_reply.started":"2024-07-08T02:07:20.242849Z","shell.execute_reply":"2024-07-08T02:07:20.269938Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"DATA = \"/kaggle/input/leap-atmospheric-physics-ai-climsim\"\nDATA_TFREC = \"/kaggle/input/leap-train-tfrecords\"","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:07:20.272722Z","iopub.execute_input":"2024-07-08T02:07:20.273032Z","iopub.status.idle":"2024-07-08T02:07:20.279786Z","shell.execute_reply.started":"2024-07-08T02:07:20.27301Z","shell.execute_reply":"2024-07-08T02:07:20.278937Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"sample = pl.read_csv(os.path.join(DATA, \"sample_submission.csv\"), n_rows=1)\nTARGETS = sample.select(pl.exclude('sample_id')).columns\nprint(len(TARGETS))","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:07:20.280756Z","iopub.execute_input":"2024-07-08T02:07:20.280996Z","iopub.status.idle":"2024-07-08T02:07:20.386127Z","shell.execute_reply.started":"2024-07-08T02:07:20.280974Z","shell.execute_reply":"2024-07-08T02:07:20.385276Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def _parse_function(example_proto):\n    feature_description = {\n        'x': tf.io.FixedLenFeature([556], tf.float32),\n        'targets': tf.io.FixedLenFeature([368], tf.float32)\n    }\n    e = tf.io.parse_single_example(example_proto, feature_description)\n    return e['x'], e['targets']","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:07:20.387155Z","iopub.execute_input":"2024-07-08T02:07:20.387464Z","iopub.status.idle":"2024-07-08T02:07:20.392277Z","shell.execute_reply.started":"2024-07-08T02:07:20.38744Z","shell.execute_reply":"2024-07-08T02:07:20.391382Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"if is_interactive():\n    train_files = [os.path.join(DATA_TFREC, \"train_%.3d.tfrec\" % i) for i in range(1)]\n    valid_files = [os.path.join(DATA_TFREC, \"train_%.3d.tfrec\" % i) for i in range(100, 101)]\nelse: \n    train_files = [os.path.join(DATA_TFREC, \"train_%.3d.tfrec\" % i) for i in range(100)]\n    valid_files = [os.path.join(DATA_TFREC, \"train_%.3d.tfrec\" % i) for i in range(100, 101)]","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:07:20.393447Z","iopub.execute_input":"2024-07-08T02:07:20.393764Z","iopub.status.idle":"2024-07-08T02:07:20.402809Z","shell.execute_reply.started":"2024-07-08T02:07:20.393736Z","shell.execute_reply":"2024-07-08T02:07:20.401851Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"BATCH_SIZE = 1024\n\ntrain_options = tf.data.Options()\ntrain_options.deterministic = True\n\nds_train = (\n    tf.data.Dataset.from_tensor_slices(train_files)\n    .with_options(train_options)\n    .shuffle(100)\n    .interleave(\n        lambda file: tf.data.TFRecordDataset(file).map(_parse_function, num_parallel_calls=tf.data.AUTOTUNE),\n        num_parallel_calls=tf.data.AUTOTUNE,\n        cycle_length=10,\n        block_length=1000,\n        deterministic=True\n    )\n    .shuffle(4 * BATCH_SIZE)\n    .batch(BATCH_SIZE)\n    .prefetch(tf.data.AUTOTUNE)\n)\n\nds_valid = (\n    tf.data.TFRecordDataset(valid_files)\n    .map(_parse_function)\n    .batch(BATCH_SIZE)\n    .prefetch(tf.data.AUTOTUNE)\n)","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:07:20.403911Z","iopub.execute_input":"2024-07-08T02:07:20.40423Z","iopub.status.idle":"2024-07-08T02:07:22.510548Z","shell.execute_reply.started":"2024-07-08T02:07:20.404201Z","shell.execute_reply":"2024-07-08T02:07:22.509574Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"norm_x = keras.layers.Normalization()\nnorm_x.adapt(ds_train.map(lambda x, y: x).take(20 if is_interactive() else 10000))\n\nplt.scatter(\n    norm_x.mean.squeeze(),\n    norm_x.variance.squeeze() ** 0.5,\n    marker=\".\",\n    alpha=0.5\n)\nplt.xscale('log')\nplt.yscale('log')","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:07:22.511722Z","iopub.execute_input":"2024-07-08T02:07:22.513587Z","iopub.status.idle":"2024-07-08T02:07:26.188274Z","shell.execute_reply.started":"2024-07-08T02:07:22.51356Z","shell.execute_reply":"2024-07-08T02:07:26.187215Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"norm_y = keras.layers.Normalization()\nnorm_y.adapt(ds_train.map(lambda x, y: y).take(20 if is_interactive() else 10000))\n\nmean_y = norm_y.mean\nstdd_y = keras.ops.maximum(1e-10, norm_y.variance ** 0.5)\n\nplt.scatter(\n    mean_y.squeeze(),\n    stdd_y.squeeze(),\n    marker=\".\",\n    alpha=0.5\n)\nplt.xscale('log')\nplt.yscale('log')\n","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:07:26.191801Z","iopub.execute_input":"2024-07-08T02:07:26.192142Z","iopub.status.idle":"2024-07-08T02:07:27.903658Z","shell.execute_reply.started":"2024-07-08T02:07:26.192116Z","shell.execute_reply":"2024-07-08T02:07:27.90278Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"min_y = np.min(np.stack([np.min(yb, 0) for _, yb in ds_train.take(20 if is_interactive() else 10000)], 0), 0, keepdims=True)\nmax_y = np.max(np.stack([np.max(yb, 0) for _, yb in ds_train.take(20 if is_interactive() else 10000)], 0), 0, keepdims=True)","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:07:27.904641Z","iopub.execute_input":"2024-07-08T02:07:27.904893Z","iopub.status.idle":"2024-07-08T02:07:28.780201Z","shell.execute_reply.started":"2024-07-08T02:07:27.90487Z","shell.execute_reply":"2024-07-08T02:07:28.779381Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Model definition & Training","metadata":{}},{"cell_type":"code","source":"if is_interactive(): \n    epochs = 1 # \nelse:  \n    epochs = 20 # 25  # 15  # 12 \n    \nlearning_rate = 3e-4\nearly_patience = 5\nepochs_warmup = 1\nepochs_ending = 2\nsteps_per_epoch = int(np.ceil(len(train_files) * 100_000 / BATCH_SIZE))\n\nlr_scheduler = keras.optimizers.schedules.CosineDecay(\n    initial_learning_rate = 1e-6,\n    decay_steps = (epochs - epochs_warmup - epochs_ending) * steps_per_epoch, \n    alpha = 0.1,\n    warmup_target = learning_rate,\n    warmup_steps = steps_per_epoch * epochs_warmup,\n)\n\n# plt.plot([lr_scheduler(it) for it in range(0, epochs * steps_per_epoch, steps_per_epoch)]);","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:07:28.781596Z","iopub.execute_input":"2024-07-08T02:07:28.782057Z","iopub.status.idle":"2024-07-08T02:07:28.787572Z","shell.execute_reply.started":"2024-07-08T02:07:28.782025Z","shell.execute_reply":"2024-07-08T02:07:28.786612Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import tensorflow as tf\nfrom tensorflow.keras.layers import LayerNormalization, MultiHeadAttention, Dense, Dropout\n\n@keras.saving.register_keras_serializable()\nclass TransformerEncoderLayer(tf.keras.layers.Layer):\n    def __init__(self, head_size, num_heads, ff_dim, dropout=0.1, **kwargs):\n        super(TransformerEncoderLayer, self).__init__(**kwargs)\n        self.att = MultiHeadAttention(key_dim=head_size, num_heads=num_heads, dropout=dropout)\n        self.ffn = tf.keras.Sequential([\n            Dense(ff_dim, activation='gelu'),\n            Dense(25)\n        ])\n        self.layernorm1 = LayerNormalization(epsilon=1e-6)\n        self.layernorm2 = LayerNormalization(epsilon=1e-6)\n        self.dropout1 = Dropout(dropout)\n        self.dropout2 = Dropout(dropout)\n\n    def call(self, inputs, training=False):\n        attn_output = self.att(inputs, inputs)\n        attn_output = self.dropout1(attn_output, training=training)\n        out1 = self.layernorm1(inputs + attn_output)\n\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":"2024-07-08T02:07:28.788724Z","iopub.execute_input":"2024-07-08T02:07:28.78904Z","iopub.status.idle":"2024-07-08T02:07:28.803392Z","shell.execute_reply.started":"2024-07-08T02:07:28.789015Z","shell.execute_reply":"2024-07-08T02:07:28.802629Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Transformer block\n@keras.saving.register_keras_serializable()\ndef transformer_block(inputs, head_size, num_heads, ff_dim, dropout=0.3):\n    attention_output = tf.keras.layers.MultiHeadAttention(\n        key_dim=head_size, num_heads=num_heads, dropout=dropout)(inputs, inputs)\n    attention_output = tf.keras.layers.Dropout(dropout)(attention_output)\n    attention_output = tf.keras.layers.LayerNormalization(epsilon=1e-6)(attention_output + inputs)\n\n    ff_output = tf.keras.layers.Dense(ff_dim, activation='gelu')(attention_output)\n    ff_output = tf.keras.layers.Dropout(dropout)(ff_output)\n    ff_output = tf.keras.layers.Dense(inputs.shape[-1])(ff_output)\n    ff_output = tf.keras.layers.LayerNormalization(epsilon=1e-6)(ff_output + attention_output)\n\n    return ff_output\n\n# ResBlock function\n@keras.saving.register_keras_serializable()\ndef res_block(x, filters, output_filters=None, groups=8):\n    if output_filters is None:\n        output_filters = filters\n    norm1 = GroupNormalization(groups=groups, axis=-1)(x)\n    silu1 = tf.keras.layers.Activation('swish')(norm1)\n    conv1 = tf.keras.layers.Conv1D(filters, kernel_size=3, padding='same')(silu1)\n\n    norm2 = GroupNormalization(groups=groups, axis=-1)(conv1)\n    silu2 = tf.keras.layers.Activation('swish')(norm2)\n    conv2 = tf.keras.layers.Conv1D(output_filters, kernel_size=3, padding='same')(silu2)\n\n    if x.shape[-1] != conv2.shape[-1]:\n        x = tf.keras.layers.Conv1D(output_filters, kernel_size=1, padding='same')(x)\n    output = tf.keras.layers.Add()([conv2, x])\n    return output\n\n# Downsample block\n@keras.saving.register_keras_serializable()\ndef repeat_block(x, filters, repeat):\n    for _ in range(repeat):\n        x = res_block(x, filters) \n    return x\n\n# Upsample block\n@keras.saving.register_keras_serializable()\ndef upsample_block(x, filters, repeat, concat_layer):\n    x = tf.keras.layers.Conv1DTranspose(filters, kernel_size=2, strides=2, padding='same')(x)\n    x = tf.keras.layers.Concatenate()([x, concat_layer])\n    for _ in range(repeat):\n        x = res_block(x, filters)\n    return x\n\n# Define a custom Lambda function to print and remove specific data slices\n# TPU does not support printing in this manner, for compatibility, direct value retrieval is used instead.\n# This function was previously used but later removed. Hence, there might be inconsistencies.\n@keras.saving.register_keras_serializable()\ndef slice_and_print(x):\n    # Print the first 2 time steps that are being removed\n    tf.print(\"Removed start:\", x[:, :2, :], summarize=-1)\n    # Print the last 2 time steps that are being removed\n    tf.print(\"Removed end:\", x[:, -2:, :], summarize=-1)\n    # Return the data after removing the padding from the start and end\n    return x[:, 2:-2, :] ","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:07:28.804574Z","iopub.execute_input":"2024-07-08T02:07:28.805214Z","iopub.status.idle":"2024-07-08T02:07:28.823566Z","shell.execute_reply.started":"2024-07-08T02:07:28.805178Z","shell.execute_reply":"2024-07-08T02:07:28.822621Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"![image.png](attachment:a51dd9bf-b4b1-429e-b6f4-518d9414a419.png)","metadata":{},"attachments":{"a51dd9bf-b4b1-429e-b6f4-518d9414a419.png":{"image/png":"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"}}},{"cell_type":"code","source":"%%time\n# Path to the model file\nmodel_filepath = '/kaggle/input/leap-u-net-models/model_epoch_09.keras'\n\n# Check if the model file exists\nif os.path.exists(model_filepath):\n    print(f\"Loading model from {model_filepath}\")\n    keras.utils.clear_session()\n    custom_objects = {\n        'R2Score': tf.keras.metrics.R2Score(class_aggregation=\"variance_weighted_average\"),\n    }\n    model = keras.models.load_model(model_filepath, custom_objects)\nelse:\n    print(\"Saved model not found, training a new model\")\n    # Clear the current Keras session\n    keras.utils.clear_session() \n\n    def x_to_seq(x):\n        x_seq0 = keras.ops.transpose(keras.ops.reshape(x[:, 0:60 * 6], (-1, 6, 60)), (0, 2, 1))\n        x_seq1 = keras.ops.transpose(keras.ops.reshape(x[:, 60 * 6 + 16:60 * 9 + 16], (-1, 3, 60)), (0, 2, 1))\n        x_flat = keras.ops.reshape(x[:, 60 * 6:60 * 6 + 16], (-1, 1, 16))\n        x_flat = keras.ops.repeat(x_flat, 60, axis=1)\n        return keras.ops.concatenate([x_seq0, x_seq1, x_flat], axis=-1) \n  \n   \n    # Build 1D U-Net model\n    def create_unet(input_shape):\n        inputs = keras.layers.Input(shape=input_shape)\n\n        # Encoder\n        encoder_1 = repeat_block(inputs, 128, 2)  # 64 x 128 x 2\n        encoder_1_down = keras.layers.MaxPooling1D(pool_size=2, strides=2)(encoder_1)  # Downsample # 32 x 128\n\n        encoder_2 = repeat_block(encoder_1_down, 256, 2)  # 32 x 256 x 2\n        encoder_2_down = keras.layers.MaxPooling1D(pool_size=2, strides=2)(encoder_2)  # Downsample # 16 x 256\n\n        encoder_3 = repeat_block(encoder_2_down, 256, 2)  # 16 x 256 x 2\n        encoder_3_down = keras.layers.MaxPooling1D(pool_size=2, strides=2)(encoder_3)  # Downsample # 8 x 256\n\n        encoder_4 = repeat_block(encoder_3_down, 256, 2)  # 8 x 256 x 2\n\n        # Bottleneck (Transformer)\n        bottleneck = transformer_block(encoder_4, head_size=4, num_heads=64, ff_dim=512)\n        \n        decoder_1 = keras.layers.Concatenate()([bottleneck, encoder_4])\n        decoder_1_block = repeat_block(decoder_1, 256, 3)  # 8 x 256 x 3\n        decoder_1_upsample = keras.layers.Conv1DTranspose(256, kernel_size=2, strides=2, padding='same')(decoder_1_block)  # Upsample # 16 x 256\n\n        decoder_2 = keras.layers.Concatenate()([decoder_1_upsample, encoder_3])\n        decoder_2_block = repeat_block(decoder_2, 256, 3)  # 16 x 256 x 3\n        decoder_2_upsample = keras.layers.Conv1DTranspose(256, kernel_size=2, strides=2, padding='same')(decoder_2_block)  # Upsample # 32 x 256\n\n        decoder_3 = keras.layers.Concatenate()([decoder_2_upsample, encoder_2])\n        decoder_3_block = repeat_block(decoder_3, 256, 3)  # 32 x 256 x 3\n        decoder_3_upsample = keras.layers.Conv1DTranspose(256, kernel_size=2, strides=2, padding='same')(decoder_3_block)  # Upsample # 64 x 256\n\n        decoder_4 = keras.layers.Concatenate()([decoder_3_upsample, encoder_1])\n        decoder_4_block = repeat_block(decoder_4, 256, 3)  # 64 x 256 x 3\n\n        model = keras.models.Model(inputs, decoder_4_block)\n        return model\n    \n    X_input = x = keras.layers.Input(ds_train.element_spec[0].shape[1:]) \n    x = keras.layers.Normalization(mean=norm_x.mean, variance=norm_x.variance)(x)\n    x = x_to_seq(x) \n  \n    # Zero-padding at the beginning and end of the sequence to extend the length from 60 to 64\n    x = keras.layers.ZeroPadding1D(padding=(2, 2))(x)\n    # \n    e = keras.layers.Conv1D(48, 1, padding='same')(x)   \n    e = create_unet(e.shape[1:])(e)      \n      \n    # Use a Lambda layer to remove the first and last 2 time steps \n    e = e[:, 2:-2, :]\n\n    p_all = keras.layers.Conv1D(14, 1, padding='same')(e)\n    print(p_all.shape)\n    \n    p_seq = p_all[:, :, :6]\n    p_seq = keras.ops.transpose(p_seq, (0, 2, 1))\n    p_seq = keras.layers.Flatten()(p_seq)\n    assert p_seq.shape[-1] == 360\n\n    p_flat = p_all[:, :, 6:6 + 8]\n    p_flat = keras.ops.mean(p_flat, axis=1)\n    assert p_flat.shape[-1] == 8\n\n    P = keras.ops.concatenate([p_seq, p_flat], axis=1)\n\n    # Build & compile the model\n    model = keras.Model(X_input, P)\n    model.compile(\n        loss='mse', \n        optimizer=keras.optimizers.Adam(0.000001),\n        metrics=[keras.metrics.MeanSquaredError(), \n                     keras.metrics.R2Score(class_aggregation=\"variance_weighted_average\"), \n        ]  # Updated R2Score\n    )\n    model.build(tuple(ds_train.element_spec[0].shape))\n    model.summary()","metadata":{"_kg_hide-output":true,"execution":{"iopub.status.busy":"2024-07-08T02:07:28.825126Z","iopub.execute_input":"2024-07-08T02:07:28.825659Z","iopub.status.idle":"2024-07-08T02:07:40.822851Z","shell.execute_reply.started":"2024-07-08T02:07:28.82561Z","shell.execute_reply":"2024-07-08T02:07:40.821908Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"%%time\n\n# Normalize target values for training and validation datasets\nds_train_target_normalized = ds_train.map(lambda x, y: (x, (y - mean_y) / stdd_y))\nds_valid_target_normalized = ds_valid.map(lambda x, y: (x, (y - mean_y) / stdd_y))\n\nif isTrain:\n    from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping \n\n    # Model checkpoint callback\n    model_checkpoint = ModelCheckpoint(\n        filepath='model_epoch_{epoch:02d}.keras',  # Save model with epoch number\n        monitor='val_loss',  # Monitor validation loss\n        save_best_only=False,  # Save all models, not just the best one\n        save_weights_only=False,  # Save the entire model structure and weights\n        mode='min',  # 'min' indicates saving when the monitored value decreases\n        verbose=2  # Provide detailed logging\n    )\n\n    # Early stopping callback\n    early_stopping = EarlyStopping(\n        monitor='val_loss',  # Monitor validation loss\n        patience=early_patience,  # Number of epochs to wait before stopping\n        restore_best_weights=True  # Restore model weights from the epoch with the best value of the monitored quantity\n    )\n\n    # Train the model\n    history = model.fit(\n        ds_train_target_normalized,  # Training data\n        validation_data=ds_valid_target_normalized,  # Validation data\n        epochs=epochs,  # Number of epochs to train\n        verbose=1 if is_interactive() else 2,  # Verbose output\n        callbacks=[early_stopping, model_checkpoint]  # List of callbacks to apply during training\n    )\n","metadata":{"_kg_hide-output":true,"execution":{"iopub.status.busy":"2024-07-08T02:07:40.824055Z","iopub.execute_input":"2024-07-08T02:07:40.824374Z","iopub.status.idle":"2024-07-08T02:07:40.857941Z","shell.execute_reply.started":"2024-07-08T02:07:40.824348Z","shell.execute_reply":"2024-07-08T02:07:40.857053Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"if isTrain:\n    plt.plot(history.history['loss'], color='tab:blue')\n    plt.plot(history.history['val_loss'], color='tab:red')\n    plt.yscale('log');","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:07:40.858918Z","iopub.execute_input":"2024-07-08T02:07:40.85915Z","iopub.status.idle":"2024-07-08T02:07:40.896752Z","shell.execute_reply.started":"2024-07-08T02:07:40.85913Z","shell.execute_reply":"2024-07-08T02:07:40.896Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"y_valid = np.concatenate([yb for _, yb in ds_valid])\np_valid = model.predict(ds_valid, batch_size=BATCH_SIZE) * stdd_y + mean_y","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:07:40.897775Z","iopub.execute_input":"2024-07-08T02:07:40.898032Z","iopub.status.idle":"2024-07-08T02:08:10.978117Z","shell.execute_reply.started":"2024-07-08T02:07:40.898009Z","shell.execute_reply":"2024-07-08T02:08:10.977334Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"scores_valid = np.array([metrics.r2_score(y_valid[:, i], p_valid[:, i]) for i in range(len(TARGETS))])\nplt.plot(scores_valid.clip(-1, 1))","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:08:10.979217Z","iopub.execute_input":"2024-07-08T02:08:10.979546Z","iopub.status.idle":"2024-07-08T02:08:12.333695Z","shell.execute_reply.started":"2024-07-08T02:08:10.979521Z","shell.execute_reply":"2024-07-08T02:08:12.332768Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"mask = scores_valid <= 1e-3\nf\"Number of under-performing targets: {sum(mask)}\"","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:08:12.335046Z","iopub.execute_input":"2024-07-08T02:08:12.33552Z","iopub.status.idle":"2024-07-08T02:08:12.342059Z","shell.execute_reply.started":"2024-07-08T02:08:12.335485Z","shell.execute_reply":"2024-07-08T02:08:12.3411Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"f\"Clipped score: {scores_valid.clip(0, 1).mean()}\"","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:08:12.343105Z","iopub.execute_input":"2024-07-08T02:08:12.343421Z","iopub.status.idle":"2024-07-08T02:08:12.3562Z","shell.execute_reply.started":"2024-07-08T02:08:12.343396Z","shell.execute_reply":"2024-07-08T02:08:12.355297Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"del y_valid, p_valid\ngc.collect();","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:08:12.357412Z","iopub.execute_input":"2024-07-08T02:08:12.357679Z","iopub.status.idle":"2024-07-08T02:08:12.591654Z","shell.execute_reply.started":"2024-07-08T02:08:12.357656Z","shell.execute_reply":"2024-07-08T02:08:12.590602Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Submission","metadata":{}},{"cell_type":"code","source":"sample = pl.read_csv(\"/kaggle/input/leap-atmospheric-physics-ai-climsim/sample_submission.csv\")","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:08:12.592824Z","iopub.execute_input":"2024-07-08T02:08:12.59314Z","iopub.status.idle":"2024-07-08T02:08:16.172098Z","shell.execute_reply.started":"2024-07-08T02:08:12.593116Z","shell.execute_reply":"2024-07-08T02:08:16.171298Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df_test = (\n    pl.scan_csv(\"/kaggle/input/leap-atmospheric-physics-ai-climsim/test.csv\")\n    .select(pl.exclude(\"sample_id\"))\n    .cast(pl.Float32)\n    .collect()\n)","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:08:16.173168Z","iopub.execute_input":"2024-07-08T02:08:16.173454Z","iopub.status.idle":"2024-07-08T02:08:40.653239Z","shell.execute_reply.started":"2024-07-08T02:08:16.173431Z","shell.execute_reply":"2024-07-08T02:08:40.652186Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"gc.collect();","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:08:40.654582Z","iopub.execute_input":"2024-07-08T02:08:40.654947Z","iopub.status.idle":"2024-07-08T02:08:40.880131Z","shell.execute_reply.started":"2024-07-08T02:08:40.654914Z","shell.execute_reply":"2024-07-08T02:08:40.879064Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"%%time\np_test = model.predict(df_test.to_numpy(), batch_size=4 * BATCH_SIZE) * stdd_y + mean_y\np_test = np.array(p_test)\np_test[:, mask] = mean_y[:, mask]","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:08:40.881485Z","iopub.execute_input":"2024-07-08T02:08:40.881776Z","iopub.status.idle":"2024-07-08T02:09:47.312073Z","shell.execute_reply.started":"2024-07-08T02:08:40.881751Z","shell.execute_reply":"2024-07-08T02:09:47.311106Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# correction of ptend_q0002 targets (from 12 to 29)\ndf_p_test = pd.DataFrame(p_test, columns=TARGETS)\n\nfor idx in range(12, 30):\n    df_p_test[f\"ptend_q0002_{idx}\"] = -df_test[f\"state_q0002_{idx}\"].to_numpy() / 1200\n    \np_test = df_p_test.values","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:09:47.313524Z","iopub.execute_input":"2024-07-08T02:09:47.313902Z","iopub.status.idle":"2024-07-08T02:09:48.949616Z","shell.execute_reply.started":"2024-07-08T02:09:47.31387Z","shell.execute_reply":"2024-07-08T02:09:48.948389Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"#submission = sample.to_pandas()\n#submission[TARGETS] = submission[TARGETS] * p_test\n#pl.from_pandas(submission[[\"sample_id\"] + TARGETS]).write_csv(\"submission.csv\")\n\nfrom collections import OrderedDict\nimport numpy as np\nimport polars as pl\n\n#file_list = [(\"./test1.csv\",0.5), (\"./test2.csv\",0.5)]\n#file_list = [(\"./submission-0.68204-keras-baseline-seq2seq.csv\", 0.2), (\"./submission-04-15-epoch-0.69479.csv\", 0.8)]  # LB:0.69773\n#file_list = [(\"./submission-0.68204-keras-baseline-seq2seq.csv\", 0.3), (\"./submission-04-15-epoch-0.69479.csv\", 0.7)]  # 0.69817\n#file_list = [(\"./submission-0.68204-keras-baseline-seq2seq.csv\", 0.4), (\"./submission-04-15-epoch-0.69479.csv\", 0.6)]  # LB:0.69793\n#file_list = (\"./submission-0.69331.csv\", 0.45), (\"./submission-04-epoch-15-0.69479.csv\", 0.55)]  # LB:\nfile_list = [\n    (\"./submission-0.68204-keras-baseline-seq2seq.csv\", 0.2), \n    (\"./submission-03-17-epoch-17-0.69331.csv\", 0.3),\n    (\"./submission-04-15-epoch-0.69479.csv\", 0.5),\n]  # 0.70119\n\nn_count = 0\nkoef_sum = 0.0\ndata_all = []\nsample_id = None\ncolumns = None\nfor (file, koef) in file_list:\n    print(file)\n    #df_sub = pl.read_csv(file, schema=dict(sample_id=pl.String,col1=pl.Float32,col2=pl.Float32,col3=pl.Float32))\n    df_sub = pl.read_csv(file)\n    #display(df_sub)\n    if sample_id is None:\n        sample_id = df_sub['sample_id'].to_numpy()\n        columns = [col for col in df_sub.schema]\n    data_all.append(df_sub[columns[1:]].to_numpy() * koef)\n    koef_sum += koef\n    n_count += 1\n\ndata_all = np.mean(data_all, 0) * n_count / koef_sum\n\ndata_list = []\nfor i, elem in enumerate(columns):\n    if i == 0:\n        data_list.append((elem, sample_id))\n    else:\n        data_list.append((elem, data_all[:, i-1]))\n\ndf_sub = pl.DataFrame(dict(data_list))  # , schema_overrides=df_sub.schema)\ndf_sub.write_csv(\"./submission.csv\")  # , float_precision=13\ndf_sub\n","metadata":{"execution":{"iopub.status.busy":"2024-07-08T02:09:48.954992Z","iopub.execute_input":"2024-07-08T02:09:48.955338Z","iopub.status.idle":"2024-07-08T02:10:00.890008Z","shell.execute_reply.started":"2024-07-08T02:09:48.955298Z","shell.execute_reply":"2024-07-08T02:10:00.88891Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Potential Optimizations and Improvements to Consider:\n1、Fine-tune Learning Rate: Experiment with lowering the learning rate and continuing training for more epochs to potentially enhance model performance.\n\n2、Model Fusion: Integrate optimal results from open-source notebooks or other personal models to improve overall model performance through ensemble techniques.\n\n3、Explore Alternative Models: Investigate alternative models to explore potentially better results and identify models that may better fit the problem domain.\n\n4、Data Preprocessing and Post-processing: Optimize data preprocessing techniques and explore advanced post-processing methods to refine model outputs and improve accuracy.\n\nWishing everyone the best of luck!","metadata":{}}]}