{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# A very simple script for the Multiome portion of this competition\n# 1. cellwise normalized targets\n# 2. CosineSimilarity loss \n# 3. target clusters to steer the model to the actual targets","metadata":{}},{"cell_type":"code","source":"import os\n\n# Source: https://stackoverflow.com/questions/38073432/how-to-suppress-verbose-tensorflow-logging\nos.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"2\"\n# https://www.tensorflow.org/api_docs/python/tf/autograph/set_verbosity\nos.environ[\"AUTOGRAPH_VERBOSITY\"] = \"0\"\n#tf.get_logger().setLevel(\"WARNING\")\n\nimport numpy as np\nimport pandas as pd\nimport glob\nimport tensorflow as tf\nimport tensorflow.keras.backend as K\nimport random\nimport datetime\nimport tensorflow_addons as tfa\nimport matplotlib.pyplot as plt\n\nfrom sklearn.preprocessing import StandardScaler, scale\nfrom sklearn.decomposition import PCA, TruncatedSVD\nfrom sklearn.dummy import DummyRegressor\nfrom sklearn.pipeline import make_pipeline, Pipeline\nfrom sklearn.linear_model import Ridge, LinearRegression, Lasso\nfrom sklearn.metrics import mean_squared_error\n\nfrom tensorflow import keras\nfrom tensorflow.keras.layers import *\nfrom tensorflow.keras import Model\nfrom tensorflow.keras import mixed_precision\n\nfrom sklearn.metrics import log_loss, auc, roc_auc_score, mean_squared_error\nimport time\nfrom tqdm import tqdm\nfrom sklearn.model_selection import KFold, StratifiedKFold, GroupKFold\nfrom sklearn.preprocessing import MinMaxScaler\nimport gc\nfrom datetime import datetime\n\nimport scipy, scipy.sparse\nfrom sklearn.preprocessing import normalize\n\nfrom sklearn.cluster import KMeans\nimport plotnine as p9\nfrom sklearn.metrics import accuracy_score","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"policy = mixed_precision.Policy('mixed_float16')\nmixed_precision.set_global_policy(policy)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def seeding(SEED):\n    np.random.seed(SEED)\n    random.seed(SEED)\n    os.environ['PYTHONHASHSEED'] = str(SEED)\n    tf.random.set_seed(SEED)\n    print('seeding done!!!')\n\nSEED = 49001\nseeding(SEED)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_multi = pd.read_parquet('/data/kaggle/multimodal/input/open-problems-multimodal/train_multi_svd256_v2.parquet')\n\nNUM_DIMS = 64\nif NUM_DIMS < 256:\n    train_multi = train_multi.iloc[:,:NUM_DIMS]","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# autoencodings for original input\ntrain_auto_enc = pd.read_parquet('/data/kaggle/multimodal/input/open-problems-multimodal/train_multi_inputs_enc128_ubuntu55_v2.parquet')\nprint(train_auto_enc.shape)\nprint(train_auto_enc.isna().sum().sum())\ntrain_multi = train_multi.merge(train_auto_enc, left_index=True, right_index=True, how='left')\n\ndel train_auto_enc\n_ = gc.collect()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# auto encoding for raw counts\ntrain_auto_enc = pd.read_parquet('/data/kaggle/multimodal/input/open-problems-multimodal/train_multi_inp_enc128_ubuntu63_raw_scaled.parquet')\nprint(train_auto_enc.shape)\nprint(train_auto_enc.isna().sum().sum())\ntrain_multi = train_multi.merge(train_auto_enc, left_index=True, right_index=True, how='left')\n\ndel train_auto_enc\n_ = gc.collect()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_multi.isna().sum().sum()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"GENEID_COLS_TO_USE = train_multi.columns.values\nprint(len(GENEID_COLS_TO_USE))\n\nNUM_GENE_ID_COLS = len(GENEID_COLS_TO_USE)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"## raw counts data doesnt not have 74 cellids that are there in the original inputs.\nprint(train_multi.shape)\ntrain_multi = train_multi.dropna(subset = GENEID_COLS_TO_USE)\nprint(train_multi.shape)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"meta_data = pd.read_csv('/data/kaggle/multimodal/input/open-problems-multimodal/metadata.csv')\nmeta_data = meta_data.loc[meta_data.technology == 'multiome']\nmeta_data.drop(columns=['technology'], inplace = True)\nmeta_data = meta_data.set_index('cell_id')\n\ntrain_multi = train_multi.merge(meta_data, left_index=True, right_index=True, how='left')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"%%time\n\n## targets are normalized - np.normalize, so cosine similarity will work\ntrain_multi_targets = pd.read_parquet('/data/kaggle/multimodal/input/open-problems-multimodal/targets_multi_normalized.parquet')\nTARGET_COLS = train_multi_targets.columns.values\nNUM_TARGETS = len(TARGET_COLS)\nprint(NUM_TARGETS)\n\ntrain_multi_targets.head(10)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_multi = train_multi.merge(train_multi_targets, left_index=True, right_index=True, how='left')\n\ndel train_multi_targets\n_ = gc.collect()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"## Target PCA for clustering only...\n## create 16 clusters in targets \ntar_multi_pca = pd.read_parquet('/data/kaggle/multimodal/input/open-problems-multimodal/target_multi_svd256_v2.parquet')\n\nNUM_CLUSTERS = 16\nkmeans = KMeans(n_clusters=NUM_CLUSTERS, random_state=SEED+10, n_init=50, max_iter=500).fit(tar_multi_pca.values)\n\ntar_multi_pca['cluster_id'] = kmeans.labels_\ntrain_multi = train_multi.merge(tar_multi_pca['cluster_id'], left_index=True, right_index=True, how='left')\n\nvalues, counts = np.unique(kmeans.labels_, return_counts=True)\nvalues, counts","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"AUTO = tf.data.experimental.AUTOTUNE\n\nBATCH_SIZE = 64\nNUM_EPOCHS = 150\nVERBOSE = 0\nNUM_FOLDS = 12","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_multi = train_multi.reset_index() ## get cell_id as col\ntrain_multi = train_multi.sample(frac=1.0) ## shuffle\ntrain_multi = train_multi.reset_index(drop = True) ## now reset index, so gkf works","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"## we want to learn embeddings for donor and days\ndonor_map = {13176:0, 31800:1, 32606:2, 27678:2} ## 27678 is like 32606, or may be 13176\nday_map = {2:0, 3:1, 4:2, 7:3, 10:1} # day 10 is like day 3, or may be 7\n\ntrain_multi['day_enc'] = train_multi['day'].map(day_map).astype('int16')\ntrain_multi['donor_enc'] = train_multi['donor'].map(donor_map).astype('int16')\n\ntrain_multi['group_helper'] = 100*train_multi['donor'] + train_multi['day']\ntrain_multi['group_helper'].value_counts().sort_index()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_multi['fold_id'] = -1\n\ngkf = GroupKFold(n_splits=NUM_FOLDS)\nfor fold, (train_idx, valid_idx) in enumerate(gkf.split(X=train_multi, groups=train_multi.group_helper)):\n    print('fold = ',fold)\n    train_multi.loc[valid_idx, 'fold_id'] = fold\n    print(train_multi.loc[valid_idx, ['donor','day']].value_counts().sort_index())","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"cluster_df = pd.get_dummies(train_multi['cluster_id'])\ncluster_cols = ['cluster_' + str(ii) for ii in range(NUM_CLUSTERS)]\ncluster_df.columns = cluster_cols\ntrain_multi = pd.concat([train_multi, cluster_df], axis = 1)\ntrain_multi.shape","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def build_cluster_model():\n    inp = tf.keras.layers.Input(shape=(NUM_GENE_ID_COLS))\n    \n    x = tf.keras.layers.Dense(512, kernel_regularizer=tf.keras.regularizers.l2(1e-5), activation=tfa.activations.mish)(inp)\n    x = tf.keras.layers.BatchNormalization()(x)\n    x = tf.keras.layers.Dropout(rate=0.1)(x)\n    x = tf.keras.layers.Dense(128, kernel_regularizer=tf.keras.regularizers.l2(1e-5), activation=tfa.activations.mish)(x)\n    x = tf.keras.layers.BatchNormalization()(x)\n    x = tf.keras.layers.Dense(128, kernel_regularizer=tf.keras.regularizers.l2(1e-5), activation=tfa.activations.mish)(x)\n    x = tf.keras.layers.BatchNormalization()(x)\n    x = tf.keras.layers.Dropout(rate=0.2)(x)\n    x = tf.keras.layers.Dense(128)(x)\n    x = tf.keras.layers.Dense(NUM_CLUSTERS, activation='softmax', dtype='float32')(x)\n    \n    model = tf.keras.Model(inputs=[inp], outputs=[x])\n\n    return model\n\nmodel1 = build_cluster_model()\nprint(model1.summary())\n\ndel model1\ngc.collect()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_multi.loc[train_idx, cluster_cols]","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"_ = gc.collect()\n\noof_cluster_preds = np.zeros((len(train_multi), NUM_CLUSTERS))\n\nCOLS_TO_USE = GENEID_COLS_TO_USE\n\nfor fold in range(NUM_FOLDS):\n    \n    print('#'*40)\n    print(' cluster id - Fold',fold, \"   Current Time =\", datetime.now().strftime(\"%H:%M:%S\"))\n    \n    train_idx = train_multi.index[train_multi['fold_id'] != fold].values\n    valid_idx = train_multi.index[train_multi['fold_id'] == fold].values \n    \n    # BUILD MODEL\n    K.clear_session()\n    \n    model = build_cluster_model()\n    model_file_name = '/data/kaggle/multimodal/models/ubuntu77e_multi-cluster-fold-%i.h5'%fold\n        \n    batches_in_each_epoch = 1 + len(train_idx)// BATCH_SIZE\n    cyclical_learning_rate = tfa.optimizers.CyclicalLearningRate(\n                initial_learning_rate=1e-6,\n                maximal_learning_rate=1e-4,\n                step_size=batches_in_each_epoch*2,\n                scale_fn=lambda x: 1 / (2.0 ** (x - 1)),\n                scale_mode='cycle')\n\n    cosine_decay = tf.keras.optimizers.schedules.CosineDecayRestarts(\n                                    initial_learning_rate = 5e-3,\n                                    first_decay_steps = 2*batches_in_each_epoch,\n                                    t_mul=1.0,\n                                    m_mul=0.8,\n                                    alpha=0.01,\n                                    name=\"cosine_decay\")\n\n    opt = tf.keras.optimizers.Adam(learning_rate=cyclical_learning_rate)\n\n    model.compile(optimizer=opt, \n                  loss=tf.keras.losses.CategoricalCrossentropy(),\n                  metrics=[tf.keras.metrics.CategoricalAccuracy()])\n\n    # SAVE BEST MODEL EACH FOLD\n    cb_model_checkpoint = tf.keras.callbacks.ModelCheckpoint(model_file_name, \n                                                             monitor='val_loss', verbose=0, save_best_only=True,\n                                                             save_weights_only=True, mode='min', save_freq='epoch')\n\n    cb_early_stopping = tf.keras.callbacks.EarlyStopping(monitor=\"val_loss\", patience=5, \n                                                         verbose=1, mode=\"min\", restore_best_weights=True)\n\n    # TRAIN\n    print('Training...')\n    history = model.fit(train_multi.loc[train_idx, COLS_TO_USE].values, \n                        train_multi.loc[train_idx, cluster_cols].values,\n                        epochs=NUM_EPOCHS, \n                        callbacks = [cb_model_checkpoint, cb_early_stopping],\n                        batch_size = BATCH_SIZE,\n                        shuffle=True,\n                        validation_data = (train_multi.loc[valid_idx, COLS_TO_USE].values, train_multi.loc[valid_idx, cluster_cols].values), \n                        verbose = 0\n                        )\n    \n    model.load_weights(model_file_name)\n    \n    oof_cluster_preds[valid_idx] = model.predict(train_multi.loc[valid_idx, COLS_TO_USE].values, batch_size=64, verbose=1)\n    \n    fold_preds = np.argmax(oof_cluster_preds[valid_idx], axis = 1)\n    acc = accuracy_score(train_multi.loc[valid_idx, 'cluster_id'].values, fold_preds)\n    print('fold aucc =',acc,'\\n')\n    \n    del model\n    _ = gc.collect()\n    \nacc = accuracy_score(train_multi.cluster_id.values, np.argmax(oof_cluster_preds, axis = 1))\nprint('OVERALL cluser_id aucc =',acc,'\\n')\n    \nCLUSTER_PRED_COLS = ['cluster_pred_' + str(ii) for ii in range(NUM_CLUSTERS)]\ntrain_multi[CLUSTER_PRED_COLS] = oof_cluster_preds","metadata":{"tags":[]},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"## got this from kaggle public scripts for this competition\ndef correlation_score(y_true, y_pred):\n    \"\"\"Scores the predictions according to the competition rules. \n    \n    It is assumed that the predictions are not constant.\n    \n    Returns the average of each sample's Pearson correlation coefficient\"\"\"\n    #if type(y_true) == pd.DataFrame: y_true = y_true.values\n    #if type(y_pred) == pd.DataFrame: y_pred = y_pred.values\n    if y_true.shape != y_pred.shape: raise ValueError(\"Shapes are different.\")\n    corrsum = 0\n    for i in range(len(y_true)):\n        corrsum += np.corrcoef(y_true[i], y_pred[i])[1, 0]\n    return corrsum / len(y_true)\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"## got this from kaggle public scripts for this competition\ndef pearsonr(y_true, y_pred):\n    x = tf.convert_to_tensor(y_true)\n    y = tf.convert_to_tensor(y_pred)\n    mx = K.mean(x,axis=1)\n    my = K.mean(y,axis=1)\n    mx = tf.tile(tf.expand_dims(mx,axis=1),(1,x.shape[1]))\n    my = tf.tile(tf.expand_dims(my,axis=1),(1,x.shape[1]))\n    xm, ym = (x-mx)/100, (y-my)/100\n    r_num = K.sum(tf.multiply(xm,ym),axis=1)\n    r_den = tf.sqrt(tf.multiply(K.sum(K.square(xm),axis=1), K.sum(K.square(ym),axis=1)))\n    r = tf.reduce_mean(r_num / r_den)\n    \n    ## ideally the value is between -1 and 1, but if we clip\n    ## it we will never know if the above compuation is wrong\n    r = K.maximum(K.minimum(r, 10.0), -10.0)\n    \n    return r","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def build_model():\n    inp = tf.keras.layers.Input(shape=(NUM_GENE_ID_COLS+2 + NUM_CLUSTERS))\n    \n    donor_emb = tf.keras.layers.Embedding(4,16)(inp[:,0])\n    day_emb = tf.keras.layers.Embedding(4,16)(inp[:,1])\n    \n    x = tf.keras.layers.Dense(256, kernel_regularizer=tf.keras.regularizers.l2(1e-5), activation='swish')(inp[:,2:])\n    x = tf.keras.layers.BatchNormalization()(x)\n    x = tf.keras.layers.Dropout(rate=0.1)(x)\n    \n    x = tf.keras.layers.Concatenate()([donor_emb, day_emb, x])\n    x = tf.keras.layers.Dense(128, kernel_regularizer=tf.keras.regularizers.l2(1e-5), activation='swish')(x)\n    x = tf.keras.layers.BatchNormalization()(x)\n    x = tf.keras.layers.Dense(1024, kernel_regularizer=tf.keras.regularizers.l2(1e-5), activation='swish')(x)\n    x = tf.keras.layers.BatchNormalization()(x)\n    x = tf.keras.layers.Dropout(rate=0.2)(x)\n    x = tf.keras.layers.Dense(NUM_TARGETS, activation='relu', dtype='float32')(x)\n    \n    model = tf.keras.Model(inputs=[inp], outputs=x)\n\n    return model\n\nmodel1 = build_model()\nprint(model1.summary())","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"_ = gc.collect()\n\noof_preds = np.zeros((len(train_multi), NUM_TARGETS))\n\nCOLS_TO_USE = np.concatenate([['donor_enc', 'day_enc'], GENEID_COLS_TO_USE, CLUSTER_PRED_COLS])\n\nfor fold in range(NUM_FOLDS):\n    \n    print('#'*40)\n    print(\"       Current Time =\", datetime.now().strftime(\"%H:%M:%S\"))\n    print('       Fold',fold)\n    print('#'*40) \n    \n    train_idx = train_multi.index[train_multi['fold_id'] != fold].values\n    valid_idx = train_multi.index[train_multi['fold_id'] == fold].values \n    \n    print(train_multi.loc[valid_idx, ['donor', 'day']].value_counts().sort_index())\n    \n    # BUILD MODEL\n    K.clear_session()\n    \n    model = build_model()\n    model_file_name = '/data/kaggle/multimodal/models/ubuntu77e_multi-fold-%i.h5'%fold\n    \n    \n    batches_in_each_epoch = 1 + len(train_idx)// BATCH_SIZE\n    cyclical_learning_rate = tfa.optimizers.CyclicalLearningRate(\n                initial_learning_rate=1e-5,\n                maximal_learning_rate=1e-3,\n                step_size=batches_in_each_epoch*2,\n                scale_fn=lambda x: 1 / (2.0 ** (x - 1)),\n                scale_mode='cycle')\n\n    opt = tf.keras.optimizers.Adam(learning_rate=cyclical_learning_rate)\n    #loss1 = tf.keras.losses.MeanSquaredError() \n    loss2 = tf.keras.losses.CosineSimilarity(axis=1,reduction=tf.keras.losses.Reduction.AUTO)\n    model.compile(optimizer=opt, \n                  loss=loss2, \n                  metrics=[pearsonr])\n\n    # SAVE BEST MODEL EACH FOLD\n    cb_model_checkpoint = tf.keras.callbacks.ModelCheckpoint(model_file_name, \n                                                             monitor='val_pearsonr', verbose=0, save_best_only=True,\n                                                             save_weights_only=True, mode='max', save_freq='epoch')\n\n    cb_early_stopping = tf.keras.callbacks.EarlyStopping(monitor=\"val_pearsonr\", patience=20, \n                                                         verbose=1, mode=\"max\", restore_best_weights=True)\n\n    # TRAIN\n    print('Training...')\n    history = model.fit(train_multi.loc[train_idx, COLS_TO_USE].values, \n                        train_multi.loc[train_idx, TARGET_COLS].values,\n                        epochs=NUM_EPOCHS, \n                        callbacks = [cb_model_checkpoint, cb_early_stopping],\n                        batch_size = BATCH_SIZE,\n                        shuffle=True,\n                        validation_data = (train_multi.loc[valid_idx, COLS_TO_USE].values, train_multi.loc[valid_idx, TARGET_COLS].values), \n                        verbose = VERBOSE)\n    \n    model.load_weights(model_file_name)\n    \n    fold_oof_pred = model.predict(train_multi.loc[valid_idx, COLS_TO_USE].values, batch_size=16, verbose=1)\n    fold_oof_pred = normalize(fold_oof_pred, axis = 1)\n    oof_preds[valid_idx] = fold_oof_pred\n    \n    fold_score = correlation_score(train_multi.loc[valid_idx, TARGET_COLS].values, fold_oof_pred)\n    print(\"fold pearson corr = \",fold_score)\n    \n    del fold_oof_pred, model, \n    _ = gc.collect()\n    \n    K.clear_session()\n    \nprint('#'*60)\noverall_score = correlation_score(train_multi[TARGET_COLS].values, oof_preds)\nprint(\"        OVERALL pearson corr = \",overall_score)\nprint('#'*60)","metadata":{"tags":[]},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"%%time\n\n## save oof in case you need to ensemble\n\noof_preds = oof_preds.astype(np.float32)\n\noof_df1 = pd.DataFrame(data={'cell_id':train_multi.cell_id.values})\noof_df3 = pd.DataFrame(data=oof_preds, columns=['predicted_'+cc for cc in TARGET_COLS])\noof_df = pd.concat([oof_df1, oof_df3], axis = 1)\nprint(oof_df.shape)\n\noof_df.to_parquet('/data/kaggle/multimodal/output/val_ubuntu77e_multi.parquet', index=False)\nprint(oof_df.head(10))\n\n\ndel oof_df, oof_df1, oof_df3\n_ = gc.collect()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_multi = pd.read_parquet('/data/kaggle/multimodal/input/open-problems-multimodal/test_multi_svd256_v2.parquet')\n\nif NUM_DIMS < 256:\n    test_multi = test_multi.iloc[:,:NUM_DIMS]\n    \ntest_auto_enc = pd.read_parquet('/data/kaggle/multimodal/input/open-problems-multimodal/test_multi_inputs_enc128_ubuntu55_v2.parquet')\ntest_multi = test_multi.merge(test_auto_enc, left_index=True, right_index=True, how='left')\nprint(test_multi.isna().sum().sum())\ndel test_auto_enc\n_ = gc.collect()\n\ntest_auto_enc = pd.read_parquet('/data/kaggle/multimodal/input/open-problems-multimodal/test_multi_inp_enc128_ubuntu63_raw_scaled.parquet')\ntest_multi = test_multi.merge(test_auto_enc, left_index=True, right_index=True, how='left')\nprint(test_multi.isna().sum().sum())\ndel test_auto_enc\n_ = gc.collect()\n    \ntest_multi = test_multi.merge(meta_data, left_index=True, right_index=True, how='left')\ntest_preds = np.zeros((len(test_multi), NUM_TARGETS))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"## merge cluster predictions\n_ = gc.collect()\n\ntest_cluster_preds = np.zeros((len(test_multi), NUM_CLUSTERS))\nCOLS_TO_USE = GENEID_COLS_TO_USE\n\nfor fold in range(NUM_FOLDS):\n    model = build_cluster_model()\n    model_file_name = '/data/kaggle/multimodal/models/ubuntu77e_multi-cluster-fold-%i.h5'%fold    \n    model.load_weights(model_file_name)\n    \n    test_cluster_preds += model.predict(test_multi[COLS_TO_USE].values, batch_size=64, verbose=1)/NUM_FOLDS\n    \n    del model\n    _ = gc.collect()\n    \ntest_multi[CLUSTER_PRED_COLS] = test_cluster_preds","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"COLS_TO_USE = np.concatenate([['donor_enc', 'day_enc'], GENEID_COLS_TO_USE, CLUSTER_PRED_COLS])\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# map donor and day in test to those found in exploratory analysis","metadata":{}},{"cell_type":"code","source":"donor_map = {13176:0, 31800:1, 32606:2, 27678:2} ## 27678 is like 32606, or may be 31800\nday_map = {2:0, 3:1, 4:2, 7:3, 10:3} # day 10 is like day 7\ntest_multi['day_enc'] = test_multi['day'].map(day_map).astype('int16')\ntest_multi['donor_enc'] = test_multi['donor'].map(donor_map).astype('int16')\n\nfor fold in range(NUM_FOLDS):\n    model = build_model()\n    model.load_weights('/data/kaggle/multimodal/models/ubuntu77e_multi-fold-%i.h5'%fold)\n    \n    test_fold_pred = model.predict(test_multi[COLS_TO_USE])\n    test_fold_pred = normalize(test_fold_pred, axis = 1)\n    test_preds += test_fold_pred\n    \n    del model\n    gc.collect()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"donor_map = {13176:0, 31800:1, 32606:2, 27678:2} ## 27678 is like 32606, or may be 31800\nday_map = {2:0, 3:1, 4:2, 7:3, 10:1} # day 10 is like day 3\ntest_multi['day_enc'] = test_multi['day'].map(day_map).astype('int16')\ntest_multi['donor_enc'] = test_multi['donor'].map(donor_map).astype('int16')\n\nfor fold in range(NUM_FOLDS):\n    model = build_model()\n    model.load_weights('/data/kaggle/multimodal/models/ubuntu77e_multi-fold-%i.h5'%fold)\n    \n    test_fold_pred = model.predict(test_multi[COLS_TO_USE])\n    test_fold_pred = normalize(test_fold_pred, axis = 1)\n    test_preds += test_fold_pred\n    \n    del model\n    gc.collect()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"donor_map = {13176:0, 31800:1, 32606:2, 27678:1} ## 27678 is like 32606, or may be 31800\nday_map = {2:0, 3:1, 4:2, 7:3, 10:3} # day 10 is like day 7\ntest_multi['day_enc'] = test_multi['day'].map(day_map).astype('int16')\ntest_multi['donor_enc'] = test_multi['donor'].map(donor_map).astype('int16')\n\nfor fold in range(NUM_FOLDS):\n    model = build_model()\n    model.load_weights('/data/kaggle/multimodal/models/ubuntu77e_multi-fold-%i.h5'%fold)\n    \n    test_fold_pred = model.predict(test_multi[COLS_TO_USE])\n    test_fold_pred = normalize(test_fold_pred, axis = 1)\n    test_preds += test_fold_pred\n    \n    del model\n    gc.collect()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"donor_map = {13176:0, 31800:1, 32606:2, 27678:1} ## 27678 is like 32606, or may be 31800\nday_map = {2:0, 3:1, 4:2, 7:3, 10:1} # day 10 is like day 3\ntest_multi['day_enc'] = test_multi['day'].map(day_map).astype('int16')\ntest_multi['donor_enc'] = test_multi['donor'].map(donor_map).astype('int16')\n\nfor fold in range(NUM_FOLDS):\n    model = build_model()\n    model.load_weights('/data/kaggle/multimodal/models/ubuntu77e_multi-fold-%i.h5'%fold)\n    \n    test_fold_pred = model.predict(test_multi[COLS_TO_USE])\n    test_fold_pred = normalize(test_fold_pred, axis = 1)\n    test_preds += test_fold_pred\n    \n    del model\n    gc.collect()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_preds = test_preds/(4*NUM_FOLDS)\n\ntest_preds = test_preds.astype(np.float32)\n\ntest_pred_df = pd.DataFrame(data=test_preds, columns=TARGET_COLS)\ntest_pred_df = pd.concat([pd.DataFrame(data={'cell_id':test_multi.index.values}), test_pred_df], axis = 1)\nprint(test_pred_df.shape)\nprint(test_pred_df.head(10))\ntest_pred_df.to_parquet('/data/kaggle/multimodal/output/sub_ubuntu77e_multi.parquet', index=False)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}