add locally connected layers

Author: levinas

P1B3/p1b3.py

@@ -55,7 +55,6 @@ def scale(df, scaling=None):
 
     mat = df.as_matrix()
     mat = scaler.fit_transform(mat)
-    # print(mat.shape)
     df = pd.DataFrame(mat, columns=df.columns)
 
     return df
@@ -81,13 +80,10 @@ def impute_and_scale(df, scaling='std'):
         return pd.DataFrame(mat, columns=df.columns)
 
     if scaling == 'maxabs':
-        # Normalizing -1 to 1
         scaler = MaxAbsScaler()
     elif scaling == 'minmax':
-        # Scaling to [0,1]
         scaler = MinMaxScaler()
     else:
-        # Standard normalization
         scaler = StandardScaler()
 
     mat = scaler.fit_transform(mat)
@@ -291,8 +287,10 @@ def __init__(self, val_split=0.2, shuffle=True, drug_features='descriptors',
 
         self.df_cellline = load_cellline_expressions(cell_expr_path, ncols=feature_subsample, scaling=scaling)
 
-        df = load_dose_response(dose_resp_path, min_logconc=min_logconc, max_logconc=max_logconc, subsample='naive_balancing')
+        df = load_dose_response(dose_resp_path, min_logconc=min_logconc, max_logconc=max_logconc, subsample=subsample)
         logger.info('Loaded {} unique (D, CL) response sets.'.format(df.shape[0]))
+        # df[['GROWTH', 'LOG_CONCENTRATION']].to_csv('all.response.csv')
+
         df = df.reset_index()
         df = df.merge(self.df_cellline[['CELLNAME']], on='CELLNAME')
 
@@ -310,6 +308,7 @@ def __init__(self, val_split=0.2, shuffle=True, drug_features='descriptors',
             self.df_drug_rand = df_rand.reset_index()
 
         logger.debug('Filltered down to {} rows with matching information.'.format(df.shape[0]))
+        # df[['GROWTH', 'LOG_CONCENTRATION']].to_csv('filtered.response.csv')
 
         df_test_cell = pd.read_csv(test_cell_path)
         df_test_drug = pd.read_csv(test_drug_path, dtype={'NSC':object})
@@ -361,16 +360,21 @@ def __init__(self, val_split=0.2, shuffle=True, drug_features='descriptors',
         logger.info('Rows in train: {}, val: {}, test: {}'.format(self.n_train, self.n_val, self.n_test))
 
         self.input_dim = self.df_cellline.shape[1] - 1 + 1  # remove CELLNAME; add concentration
+        logger.info('Features:')
+        logger.info('  concentration: 1')
+        logger.info('  cell line expression: {}'.format(self.input_dim-1))
         if self.drug_features in ['descriptors', 'both']:
             self.input_dim += self.df_drug_desc.shape[1] - 1  # remove NSC
+            logger.info('  drug descriptors: {}'.format(self.df_drug_desc.shape[1] - 1))
         if self.drug_features in ['latent', 'both']:
             self.input_dim += self.df_drug_auen.shape[1] - 1  # remove NSC
+            logger.info('  drug latent representations: {}'.format(self.df_drug_auen.shape[1] - 1))
         if self.drug_features == 'noise':
             self.input_dim += self.df_drug_rand.shape[1] - 1  # remove NSC
+            logger.info('  drug random vectors: {}'.format(self.df_drug_rand.shape[1] - 1))
+        logger.info('Total input dimensions: {}'.format(self.input_dim))
 
-        logger.info('Input dim = {}'.format(self.input_dim))
-
-    def flow(self, batch_size=32, data='train', reshape=False):
+    def flow(self, batch_size=32, data='train', topology=None):
         if data == 'val':
             cyc = self.cycle_val
         elif data == 'test':
@@ -398,7 +402,8 @@ def flow(self, batch_size=32, data='train', reshape=False):
             x = np.array(df.iloc[:, 1:])
             y = np.array(df.iloc[:, 0])
             y = y / 100.
-            if reshape:
+
+            if topology == 'simple_local':
                 yield x.reshape(x.shape + (1,)), y
                 # yield x.reshape(x.shape[0], 1, x.shape[1]), y
             else:

P1B3/p1b3_baseline.py

@@ -17,7 +17,7 @@
 from keras import backend as K
 from keras import metrics
 from keras.models import Sequential
-from keras.layers import Dense, Dropout
+from keras.layers import Dense, Dropout, LocallyConnected1D, MaxPooling1D, Flatten
 from keras.callbacks import Callback, ModelCheckpoint, ProgbarLogger
 
 from sklearn.preprocessing import Imputer
@@ -64,6 +64,13 @@
 D4 = 50
 DENSE_LAYERS = [D1, D2, D3, D4]
 
+# Number of units per locally connected layer
+LC1 = 10, 1        # nb_filter, filter_length
+LC2 = 0, 0         # disabled layer
+# LOCALLY_CONNECTED_LAYERS = list(LC1 + LC2)
+LOCALLY_CONNECTED_LAYERS = [0, 0]
+POOL = 100
+
 MIN_LOGCONC = -5.
 MAX_LOGCONC = -4.
 
@@ -90,6 +97,9 @@ def get_parser():
     parser.add_argument("-e", "--epochs", action="store",
                         default=NB_EPOCH, type=int,
                         help="number of training epochs")
+    parser.add_argument("-l", "--locally_connected", action="store", nargs='+', type=int,
+                        default=LOCALLY_CONNECTED_LAYERS,
+                        help="integer array describing locally connected layers: layer1_nb_filter, layer1_filter_len, layer2_nb_filter, layer2_filter_len, ...")
     parser.add_argument("-o", "--optimizer", action="store",
                         default=OPTIMIZER,
                         help="keras optimizer to use: sgd, rmsprop, ...")
@@ -99,6 +109,9 @@ def get_parser():
     parser.add_argument("--loss", action="store",
                         default=LOSS,
                         help="keras loss function to use: mse, ...")
+    parser.add_argument("--pool", action="store",
+                        default=POOL, type=int,
+                        help="pooling layer length")
     parser.add_argument("--scaling", action="store",
                         default=SCALING,
                         help="type of feature scaling; 'minabs': to [-1,1]; 'minmax': to [0,1], 'std': standard unit normalization; None: no normalization")
@@ -147,6 +160,16 @@ def extension_from_parameters(args):
     ext += '.E={}'.format(args.epochs)
     if args.feature_subsample:
         ext += '.F={}'.format(args.feature_subsample)
+    if args.locally_connected:
+        layer_list = list(range(0, len(args.locally_connected), 2))
+        for l, i in enumerate(layer_list):
+            nb_filter = args.locally_connected[i]
+            filter_len = args.locally_connected[i+1]
+            if nb_filter <= 0 or filter_len <= 0:
+                break
+            ext += '.LC{}={},{}'.format(l+1, nb_filter, filter_len)
+        if args.pool and layer_list[0] and layer_list[1]:
+            ext += '.P={}'.format(args.pool)
     for i, n in enumerate(args.dense):
         if n:
             ext += '.D{}={}'.format(i+1, n)
@@ -289,13 +312,23 @@ def main():
                                            subsample=args.subsample,
                                            category_cutoffs=args.category_cutoffs)
 
-    train_gen = datagen.flow(batch_size=args.batch_size)
-    val_gen = datagen.flow(data='val', batch_size=args.batch_size)
-    val_gen2 = datagen.flow(data='val', batch_size=args.batch_size)
-    test_gen = datagen.flow(data='test', batch_size=args.batch_size)
-
+    topology = 'dense'
     out_dim = 1
+
     model = Sequential()
+    if args.locally_connected and args.locally_connected[0]:
+        topology = 'simple_local'
+        layer_list = list(range(0, len(args.locally_connected), 2))
+        for l, i in enumerate(layer_list):
+            nb_filter = args.locally_connected[i]
+            filter_len = args.locally_connected[i+1]
+            if nb_filter <= 0 or filter_len <= 0:
+                break
+            model.add(LocallyConnected1D(nb_filter, filter_len, input_shape=(datagen.input_dim, 1), activation=args.activation))
+            if args.pool:
+                model.add(MaxPooling1D(pool_length=args.pool))
+        model.add(Flatten())
+
     for layer in args.dense:
         if layer:
             model.add(Dense(layer, input_dim=datagen.input_dim, activation=args.activation))
@@ -306,6 +339,11 @@ def main():
     model.summary()
     model.compile(loss=args.loss, optimizer=args.optimizer)
 
+    train_gen = datagen.flow(batch_size=args.batch_size, topology=topology)
+    val_gen = datagen.flow(data='val', batch_size=args.batch_size, topology=topology)
+    val_gen2 = datagen.flow(data='val', batch_size=args.batch_size, topology=topology)
+    test_gen = datagen.flow(data='test', batch_size=args.batch_size, topology=topology)
+
     train_samples = int(datagen.n_train/args.batch_size) * args.batch_size
     val_samples = int(datagen.n_val/args.batch_size) * args.batch_size
     test_samples = int(datagen.n_test/args.batch_size) * args.batch_size