def create_model(self, n_dim, r): # load inputs X, _, _ = self.inputs K.set_session(self.sess) with tf.name_scope('generator'): x = X L = self.layers # dim/layer: 4096, 2048, 1024, 512, 256, 128, 64, 32, n_filters = [128, 384, 512, 512, 512, 512, 512, 512] n_filtersizes = [65, 33, 17, 9, 9, 9, 9, 9, 9] downsampling_l = [] print('building model...') # downsampling layers for l, nf, fs in zip(range(L), n_filters, n_filtersizes): with tf.name_scope('downsc_conv%d' % l): x = (Convolution1D(nb_filter=nf, filter_length=fs, activation=None, border_mode='same', init=orthogonal_init, subsample_length=2))(x) # if l > 0: x = BatchNormalization(mode=2)(x) x = LeakyReLU(0.2)(x) print('D-Block: ', x.get_shape()) downsampling_l.append(x) # bottleneck layer with tf.name_scope('bottleneck_conv'): x = (Convolution1D(nb_filter=n_filters[-1], filter_length=n_filtersizes[-1], activation=None, border_mode='same', init=orthogonal_init, subsample_length=2))(x) x = Dropout(p=0.5)(x) x = LeakyReLU(0.2)(x) # upsampling layers for l, nf, fs, l_in in list(reversed(list(zip(range(L), n_filters, n_filtersizes, downsampling_l)))): with tf.name_scope('upsc_conv%d' % l): # (-1, n/2, 2f) x = (Convolution1D(nb_filter=2*nf, filter_length=fs, activation=None, border_mode='same', init=orthogonal_init))(x) x = Dropout(p=0.5)(x) x = Activation('relu')(x) # (-1, n, f) x = SubPixel1D(x, r=2) # (-1, n, 2f) x = K.concatenate(tensors=[x, l_in], axis=2) print('U-Block: ', x.get_shape()) # final conv layer with tf.name_scope('lastconv'): x = Convolution1D(nb_filter=2, filter_length=9, activation=None, border_mode='same', init=normal_init)(x) x = SubPixel1D(x, r=2) print(x.get_shape()) g = merge([x, X], mode='sum') return g
def unet3D(x_in, img_shape, out_im_chans, nf_enc=[64, 64, 128, 128, 256, 256, 512], nf_dec=None, layer_prefix='unet', n_convs_per_stage=1, ): ks = 3 x = x_in encodings = [] encoding_vol_sizes = [] for i in range(len(nf_enc)): for j in range(n_convs_per_stage): x = Conv3D( nf_enc[i], kernel_size=ks, strides=(1, 1, 1), padding='same', name='{}_enc_conv3D_{}_{}'.format(layer_prefix, i, j + 1))(x) x = LeakyReLU(0.2)(x) encodings.append(x) encoding_vol_sizes.append(np.asarray(x.get_shape().as_list()[1:-1])) if i < len(nf_enc) - 1: x = MaxPooling3D(pool_size=(2, 2, 2), padding='same', name='{}_enc_maxpool_{}'.format(layer_prefix, i))(x) if nf_dec is None: nf_dec = list(reversed(nf_enc[1:])) for i in range(len(nf_dec)): curr_shape = x.get_shape().as_list()[1:-1] # only do upsample if we are not yet at max resolution if np.any(curr_shape < list(img_shape[:len(curr_shape)])): us = (2, 2, 2) x = UpSampling3D(size=us, name='{}_dec_upsamp_{}'.format(layer_prefix, i))(x) # just concatenate the final layer here if i <= len(encodings) - 2: x = _pad_or_crop_to_shape_3D(x, np.asarray(x.get_shape().as_list()[1:-1]), encoding_vol_sizes[-i-2]) x = Concatenate(axis=-1)([x, encodings[-i-2]]) for j in range(n_convs_per_stage): x = Conv3D(nf_dec[i], kernel_size=ks, strides=(1, 1, 1), padding='same', name='{}_dec_conv3D_{}_{}'.format(layer_prefix, i, j))(x) x = LeakyReLU(0.2)(x) y = Conv3D(out_im_chans, kernel_size=1, padding='same', name='{}_dec_conv3D_final'.format(layer_prefix))(x) # add your own activation after this model # add your own activation after this model return y
def create_model(self, n_dim, r): # load inputs X, _, _ = self.inputs K.set_session(self.sess) with tf.name_scope('generator'): x = X L = self.layers n_filters = [ 128, 256, 512, 512, 512, 512, 512, 512] n_filtersizes = [65, 33, 17, 9, 9, 9, 9, 9, 9] downsampling_l = [] print 'building model...' # downsampling layers for l, nf, fs in zip(range(L), n_filters, n_filtersizes): with tf.name_scope('downsc_conv%d' % l): conv1d = Conv1D(filters=nf, kernel_size=fs, padding='same', kernel_initializer='orthogonal', strides=2) x = conv1d(x) x = LeakyReLU(0.2)(x) print 'D-Block: ', x.get_shape() downsampling_l.append(x) # bottleneck layer with tf.name_scope('bottleneck_conv'): conv1d = Conv1D(filters=n_filters[-1], kernel_size=n_filtersizes[-1], padding='same', kernel_initializer='orthogonal', strides=2) x = conv1d(x) x = Dropout(rate=0.5)(x) x = LeakyReLU(0.2)(x) # upsampling layers for l, nf, fs, l_in in reversed(zip(range(L), n_filters, n_filtersizes, downsampling_l)): with tf.name_scope('upsc_conv%d' % l): conv1d = Conv1D(filters=2*nf, kernel_size=fs, padding='same', kernel_initializer='orthogonal') x = (conv1d)(x) x = Dropout(rate=0.5)(x) x = Activation('relu')(x) x = SubPixel1D(x, r=2) x = Concatenate()([x, l_in]) print 'U-Block: ', x.get_shape() # final conv layer with tf.name_scope('lastconv'): x = Conv1D(filters=2, kernel_size=9, padding='same', kernel_initializer='random_normal')(x) x = SubPixel1D(x, r=2) print x.get_shape() g = Add()([x, X]) return g
def build_critic(self): #ResNet X_input = Input(shape=self.img_shape) X = X_input num_conv_layers = 6 num_res_blocks = 4 num_channels = [32, 64, 128, 256, 256, 512, 512, 512, 512] for i in range(num_conv_layers): X = Conv2D(num_channels[i], kernel_size=3, strides=2, padding="same")(X) X = LeakyReLU(alpha=0.2)(X) if num_conv_layers - i <= num_res_blocks: ResX = X X = Conv2D(X.get_shape().as_list()[-1], kernel_size=3, strides=1, padding="same")(X) X = LeakyReLU(alpha=0.2)(X) X = Conv2D(X.get_shape().as_list()[-1], kernel_size=3, strides=1, padding="same")(X) X = Add()([X, ResX]) X = LeakyReLU(alpha=0.2)(X) X = Conv2D(int(num_channels[num_conv_layers]/4), kernel_size=1, strides=1, padding="same")(X) X = LeakyReLU(alpha=0.2)(X) X = Conv2D(1, kernel_size=1, strides=1, padding="same")(X) model = Model(inputs = X_input, outputs = X) model.summary() return model
def unet3D( x_in, img_shape, out_im_chans, nf_enc=[64, 64, 128, 128, 256, 256, 512], nf_dec=None, regularizer=None, initializer=None, layer_prefix='unet', n_convs_per_stage=1, include_residual=False, use_maxpool=True, max_time_downsample=None, n_tasks=1, use_dropout=False, do_unpool=False, do_last_conv=True, ): ks = 3 if max_time_downsample is None: max_time_downsample = len( nf_enc) # downsample in time all the way down encoding_im_sizes = np.asarray([( int(np.ceil(img_shape[0] / 2.0**i)), int(np.ceil(img_shape[1] / 2.0**i)), int(np.ceil(img_shape[2] / 2.0**i)), ) for i in range(0, len(nf_enc) + 1)]) else: encoding_im_sizes = np.asarray([( int(np.ceil(img_shape[0] / 2.0**i)), int(np.ceil(img_shape[1] / 2.0**i)), max(int(np.ceil(img_shape[2] / 2.0**(max_time_downsample))), int(np.ceil(img_shape[2] / 2.0**i))), ) for i in range(0, len(nf_enc) + 1)]) reg_params = {} if regularizer == 'l1': reg = regularizers.l1(1e-6) else: reg = None if initializer == 'zeros': reg_params['kernel_initializer'] = initializers.Zeros() x = x_in encodings = [] encoding_im_sizes = [] for i in range(len(nf_enc)): if not use_maxpool and i > 0: x = LeakyReLU(0.2)(x) for j in range(n_convs_per_stage): if nf_enc[ i] is not None: # in case we dont want to convovle at max resolution x = Conv3D(nf_enc[i], kernel_regularizer=reg, kernel_size=ks, strides=(1, 1, 1), padding='same', name='{}_enc_conv3D_{}_{}'.format( layer_prefix, i, j + 1))(x) #if use_dropout: # x = Dropout(0.2)(x) if j == 0 and include_residual: residual_input = x elif j == n_convs_per_stage - 1 and include_residual: x = Add()([residual_input, x]) x = LeakyReLU(0.2)(x) encodings.append(x) encoding_im_sizes.append(np.asarray(x.get_shape().as_list()[1:-1])) # only downsample if we haven't reached the max if i >= max_time_downsample: ds = (2, 2, 1) else: ds = (2, 2, 2) if i < len(nf_enc) - 1: if use_maxpool: x = MaxPooling3D(pool_size=ds, padding='same', name='{}_enc_maxpool_{}'.format( layer_prefix, i))(x) #x, pool_idxs = Lambda(lambda x:._max_pool_3d_with_argmax(x, ksize=ks, strides=(2, 2, 2), padding='same'), name='{}_enc_maxpool3dwithargmax_{}'.format(layer_prefix, i))(x) else: x = Conv3D(nf_enc[i], kernel_size=ks, strides=ds, padding='same', name='{}_enc_conv3D_{}'.format(layer_prefix, i))(x) if nf_dec is None: nf_dec = list(reversed(nf_enc[1:])) decoder_outputs = [] x_encoded = x print(encoding_im_sizes) print(nf_dec) for ti in range(n_tasks): decoding_im_sizes = [] x = x_encoded for i in range(len(nf_dec)): curr_shape = x.get_shape().as_list()[1:-1] print('Current shape {}, img shape {}'.format( x.get_shape().as_list(), img_shape)) # only do upsample if we are not yet at max resolution if np.any(curr_shape < list(img_shape[:len(curr_shape)])): # TODO: fix this for time ''' if i < len(nf_dec) - max_time_downsample + 1 \ or curr_shape[-1] >= encoding_im_sizes[-i-2][-1]: # if we are already at the correct time scale us = (2, 2, 1) else: ''' us = (2, 2, 2) #decoding_im_sizes.append(encoding_im_sizes[-i-1] * np.asarray(us)) x = UpSampling3D(size=us, name='{}_dec{}_upsamp_{}'.format( layer_prefix, ti, i))(x) # just concatenate the final layer here if i <= len(encodings) - 2: x = _pad_or_crop_to_shape_3D( x, np.asarray(x.get_shape().as_list()[1:-1]), encoding_im_sizes[-i - 2]) x = Concatenate(axis=-1)([x, encodings[-i - 2]]) #x = LeakyReLU(0.2)(x) residual_input = x for j in range(n_convs_per_stage): x = Conv3D(nf_dec[i], kernel_regularizer=reg, kernel_size=ks, strides=(1, 1, 1), padding='same', name='{}_dec{}_conv3D_{}_{}'.format( layer_prefix, ti, i, j))(x) if use_dropout and i < 2: x = Dropout(0.2)(x) if j == 0 and include_residual: residual_input = x elif j == n_convs_per_stage - 1 and include_residual: x = Add()([residual_input, x]) x = LeakyReLU(0.2)(x) if do_last_conv: y = Conv3D(out_im_chans, kernel_size=1, padding='same', kernel_regularizer=reg, name='{}_dec{}_conv3D_final'.format(layer_prefix, ti))( x) # add your own activation after this model else: y = x decoder_outputs.append(y) # add your own activation after this model if n_tasks == 1: return y else: return decoder_outputs
def unet2D( x_in, input_shape, out_im_chans, nf_enc=[64, 64, 128, 128, 256, 256, 512], nf_dec=None, regularizer=None, initializer=None, layer_prefix='unet', n_convs_per_stage=1, use_residuals=False, use_maxpool=False, concat_at_stages=None, do_last_conv=True, ks=3, ): reg_params = {} if regularizer == 'l1': reg = regularizers.l1(1e-6) else: reg = None if initializer == 'zeros': reg_params['kernel_initializer'] = initializers.Zeros() x = x_in encodings = [] for i in range(len(nf_enc)): if not use_maxpool and i > 0: x = LeakyReLU(0.2)(x) for j in range(n_convs_per_stage): if nf_enc[ i] is not None: # in case we dont want to convolve at the first resolution x = Conv2D(nf_enc[i], kernel_regularizer=reg, kernel_size=ks, strides=(1, 1), padding='same', name='{}_enc_conv2D_{}_{}'.format( layer_prefix, i, j + 1))(x) if concat_at_stages and concat_at_stages[i] is not None: x = Concatenate(axis=-1)([x, concat_at_stages[i]]) if j == 0 and use_residuals: residual_input = x elif j == n_convs_per_stage - 1 and use_residuals: x = Add()([residual_input, x]) x = LeakyReLU(0.2)(x) if i < len(nf_enc) - 1: encodings.append(x) if use_maxpool: x = MaxPooling2D(pool_size=(2, 2), padding='same', name='{}_enc_maxpool_{}'.format( layer_prefix, i))(x) else: x = Conv2D(nf_enc[i], kernel_size=ks, strides=(2, 2), padding='same', name='{}_enc_conv2D_{}'.format(layer_prefix, i))(x) print('Encodings to concat later: {}'.format(encodings)) if nf_dec is None: nf_dec = list(reversed(nf_enc[1:])) print('Decoder channels: {}'.format(nf_dec)) for i in range(len(nf_dec)): curr_shape = x.get_shape().as_list()[1:-1] # if we're not at full resolution, keep upsampling if np.any(list(curr_shape[:2]) < list(input_shape[:2])): x = UpSampling2D(size=(2, 2), name='{}_dec_upsamp_{}'.format(layer_prefix, i))(x) # if we still have things to concatenate, do that if (i + 1) <= len(encodings): curr_shape = x.get_shape().as_list()[1:-1] concat_with_shape = encodings[-i - 1].get_shape().as_list()[1:-1] x = _pad_or_crop_to_shape(x, curr_shape, concat_with_shape) x = Concatenate()([x, encodings[-i - 1]]) residual_input = x for j in range(n_convs_per_stage): x = Conv2D(nf_dec[i], kernel_regularizer=reg, kernel_size=ks, strides=(1, 1), padding='same', name='{}_dec_conv2D_{}_{}'.format(layer_prefix, i, j))(x) if j == 0 and use_residuals: residual_input = x elif j == n_convs_per_stage - 1 and use_residuals: x = Add()([residual_input, x]) x = LeakyReLU(0.2)(x) #x = Concatenate()([x, encodings[0]]) ''' for j in range(n_convs_per_stage - 1): x = Conv2D(out_im_chans, kernel_regularizer=reg, kernel_size=ks, strides=(1, 1), padding='same', name='{}_dec_conv2D_last_{}'.format(layer_prefix, j))(x) x = LeakyReLU(0.2)(x) ''' if do_last_conv: y = Conv2D(out_im_chans, kernel_size=1, padding='same', kernel_regularizer=reg, name='{}_dec_conv2D_final'.format(layer_prefix))( x) # add your own activation after this model else: y = x # add your own activation after this model return y
def create_model(self, n_dim, r): # load inputs X, _, _ = self.inputs K.set_session(self.sess) with tf.compat.v1.name_scope('generator'): x = X L = self.layers n_filters = [ 128, 256, 512, 512, 512, 512, 512, 512] n_blocks = [ 128, 64, 32, 16, 8] n_filtersizes = [65, 33, 17, 9, 9, 9, 9, 9, 9] downsampling_l = [] print('building model...') def _make_normalizer(x_in, n_filters, n_block): """applies an lstm layer on top of x_in""" x_shape = tf.shape(input=x_in) n_steps = x_shape[1] / int(n_block) # will be 32 at training # first, apply standard conv layer to reduce the dimension # input of (-1, 4096, 128) becomes (-1, 32, 128) # input of (-1, 512, 512) becomes (-1, 32, 512) x_in_down = (MaxPooling1D(pool_size=int(n_block), padding='valid'))(x_in) # pooling to reduce dimension x_shape = tf.shape(input=x_in_down) x_rnn = LSTM(units = n_filters, return_sequences = True)(x_in_down) # output: (-1, n_steps, n_filters) return x_rnn def _apply_normalizer(x_in, x_norm, n_filters, n_block): x_shape = tf.shape(input=x_in) n_steps = x_shape[1] / int(n_block) # will be 32 at training # reshape input into blocks x_in = tf.reshape(x_in, shape=(-1, n_steps, int(n_block), n_filters)) x_norm = tf.reshape(x_norm, shape=(-1, n_steps, 1, n_filters)) # multiply x_out = x_norm * x_in # return to original shape x_out = tf.reshape(x_out, shape=x_shape) return x_out # downsampling layers for l, nf, fs in zip(list(range(L)), n_filters, n_filtersizes): with tf.compat.v1.name_scope('downsc_conv%d' % l): x = (Conv1D(filters=nf, kernel_size=fs, dilation_rate = DRATE, activation=None, padding='same', kernel_initializer=Orthogonal()))(x) x = (MaxPooling1D(pool_size=self.pool_size, padding='valid', strides=self.strides))(x) x = LeakyReLU(0.2)(x) # create and apply the normalizer nb = 128 / (2**l) params_before = np.sum([np.prod(v.get_shape().as_list()) for v in tf.compat.v1.trainable_variables()]) x_norm = _make_normalizer(x, nf, nb) params_after = np.sum([np.prod(v.get_shape().as_list()) for v in tf.compat.v1.trainable_variables()]) x = _apply_normalizer(x, x_norm, nf, nb) print('D-Block: ', x.get_shape()) downsampling_l.append(x) # bottleneck layer with tf.compat.v1.name_scope('bottleneck_conv'): x = (Conv1D(filters=n_filters[-1], kernel_size=n_filtersizes[-1], dilation_rate = DRATE, activation=None, padding='same', kernel_initializer=Orthogonal))(x) x = (MaxPooling1D(pool_size=self.pool_size, padding='valid', strides=self.strides))(x) x = Dropout(rate=0.5)(x) x = LeakyReLU(0.2)(x) # create and apply the normalizer nb = 128 / (2**L) x_norm = _make_normalizer(x, n_filters[-1], nb) x = _apply_normalizer(x, x_norm, n_filters[-1], nb) # upsampling layers for l, nf, fs, l_in in reversed(list(zip(list(range(L)), n_filters, n_filtersizes, downsampling_l))): with tf.compat.v1.name_scope('upsc_conv%d' % l): # (-1, n/2, 2f) x = (Conv1D(filters=2*nf, kernel_size=fs, dilation_rate = DRATE, activation=None, padding='same', kernel_initializer=Orthogonal()))(x) x = Dropout(rate=0.5)(x) x = Activation('relu')(x) # (-1, n, f) x = SubPixel1D(x, r=2) # create and apply the normalizer x_norm = _make_normalizer(x, nf, nb) x = _apply_normalizer(x, x_norm, nf, nb) # (-1, n, 2f) x = Concatenate()([x, l_in]) print('U-Block: ', x.get_shape()) # final conv layer with tf.compat.v1.name_scope('lastconv'): x = Conv1D(filters=2, kernel_size=9, activation=None, padding='same', kernel_initializer=RandomNormal(stddev=1e-3))(x) x = SubPixel1D(x, r=2) g = Add()([x, X]) return g
def audiounet_processing(x_inp, params): n_dim = int(x_inp.get_shape()[1]) x = x_inp L = params['layers'] r = params['r'] additive_skip_connection = params['additive_skip_connection'] n_filtersizes = params['n_filtersizes'] # dim/layer è sempre : n_dim/2 , n_dim/4, n_dim/8, ... #Il numero di canali dipende invece da n_filters. if n_dim == 4096: print('n_dim = 4096') n_filters = params['n_filters_spectral_branch'] elif n_dim == 8192: print('n_dim = 8192') n_filters = params['n_filters_time_branch'] else: print('I need other n_dim') return None downsampling_l = [] # downsampling layers for l, nf, fs in zip(range(L), n_filters, n_filtersizes): with tf.name_scope('downsc_conv%d' % l): x = (Convolution1D( nb_filter=nf, filter_length=fs, activation=None, border_mode='same', input_dim=(n_dim, 1), subsample_length=2, kernel_initializer=tf.orthogonal_initializer()))( x) #init=orthogonal_init, # if l > 0: x = BatchNormalization(mode=2)(x) x = LeakyReLU(0.2)(x) print('D-Block: {}'.format(x.get_shape())) downsampling_l.append(x) #print(x) # bottleneck layer with tf.name_scope('bottleneck_conv'): x = (Convolution1D(nb_filter=n_filters[-1], filter_length=n_filtersizes[-1], activation=None, border_mode='same', subsample_length=2, kernel_initializer=tf.orthogonal_initializer()))( x) #init=orthogonal_init, x = Dropout(p=0.5)(x) x = LeakyReLU(0.2)(x) print('B-Block: {}'.format(x.get_shape())) # upsampling layers for l, nf, fs, l_in in list( zip(range(L), n_filters, n_filtersizes, downsampling_l))[::-1]: #print(l, nf, fs, l_in) with tf.name_scope('upsc_conv%d' % l): # (-1, n/2, 2f) x = (Convolution1D( nb_filter=2 * nf, filter_length=fs, activation=None, border_mode='same', kernel_initializer=tf.orthogonal_initializer()))( x) #init=orthogonal_init, x = Dropout(p=0.5)(x) x = Activation('relu')(x) # (-1, n, f) x = SubPixel1D(x, r=2) # (-1, n, 2f) x = K.concatenate(tensors=[x, l_in], axis=2) print('U-Block: {}'.format(x.get_shape())) # final conv layer with tf.name_scope('lastconv'): x = Convolution1D(nb_filter=2, filter_length=9, activation=None, border_mode='same', kernel_initializer=tf.orthogonal_initializer())( x) #init=orthogonal_init, x = SubPixel1D(x, r=2) if additive_skip_connection == True: x = tf.add(x, x_inp) return x #x è (?, 8192). // con tf.reshape(x, [-1, n_dim]) aggiungo un canale alla fine -> diventerebbe (?, 8192, 1)
def create_model(): X = Input(shape=(64, 128, 1)) with tf.name_scope('generator'): X2 = Reshape((1, -1, 1))(X) x = X2 L = 4 n_filters = [128, 256, 512, 512, 512, 512, 512, 512] n_filtersizes = [65, 33, 17, 9, 9, 9, 9, 9, 9] downsampling_l = [] print 'building model...' print 'Input: %s' % x.get_shape() # downsampling layers for l, nf, fs in zip(range(L), n_filters, n_filtersizes): with tf.name_scope('downsc_conv%d' % l): x = Conv2D(filters=nf, kernel_size=(1, fs), padding='same', kernel_initializer='orthogonal', strides=2)(x) x = LeakyReLU(0.2)(x) print 'D-Block-%d: %s' % (l, x.get_shape()) downsampling_l.append(x) # bottleneck layer with tf.name_scope('bottleneck_conv'): x = Conv2D(filters=n_filters[-1], kernel_size=(1, n_filtersizes[-1]), padding='same', kernel_initializer='orthogonal', strides=2)(x) x = Dropout(rate=0.5)(x) x = LeakyReLU(0.2)(x) print 'B-Block: ', x.get_shape() # upsampling layers for l, nf, fs, l_in in reversed( zip(range(L), n_filters, n_filtersizes, downsampling_l)): with tf.name_scope('upsc_conv%d' % l): x = Conv2D(filters=nf * 2, kernel_size=(1, fs), padding='same', kernel_initializer='orthogonal')(x) x = Dropout(rate=0.5)(x) x = Activation('relu')(x) x = subpixel1D(x, r=2) # CoreML not support 3d concatenate(axis=-1), so following error was happend. # >> raise ValueError('Only channel and sequence concatenation are supported.') # workaround: temporary reshape to 4-d, before concat back to 3-d #print 'concat', x.shape, l_in.shape s = (1, -1, int(x.shape[-1])) x = Reshape(s)(x) l_in = Reshape(s)(l_in) x = Concatenate(axis=-1)([x, l_in]) s = (1, -1, int(x.shape[-1])) x = Reshape(s)(x) print 'U-Block-%d: %s' % (l, x.get_shape()) # final conv layer with tf.name_scope('lastconv'): x = Conv2D(filters=2, kernel_size=(1, 9), padding='same', kernel_initializer='random_normal')(x) x = subpixel1D(x, r=2) print 'Last-Block-1: %s' % x.get_shape() x = Add()([x, X2]) model = Model(inputs=X, outputs=x) adam = Adam(lr=3e-4, beta_1=0.9, beta_2=0.999) model.compile(optimizer=adam, loss=mean_sqrt_l2_error, metrics=[mean_sqrt_l2_error, signal_noise_rate]) return model
def tfilm_processing(x_inp, params): n_dim = int(x_inp.get_shape()[1]) DRATE = 2 # load inputs x = x_inp L = params['layers'] r = params['r'] additive_skip_connection = params['additive_skip_connection'] n_filtersizes = params['n_filtersizes'] # dim/layer è sempre : n_dim/2 , n_dim/4, n_dim/8, ... #Il numero di canali dipende invece da n_filters. if n_dim == 4096: print('n_dim = 4096') n_filters = params['n_filters_spectral_branch'] elif n_dim == 8192: print('n_dim = 8192') n_filters = params['n_filters_time_branch'] else: print('I need other n_dim') return None downsampling_l = [] # downsampling layers for l, nf, fs in zip(range(L), n_filters, n_filtersizes): with tf.name_scope('downsc_conv%d' % l): x = (AtrousConvolution1D( nb_filter=nf, filter_length=fs, atrous_rate=DRATE, activation=None, border_mode='same', subsample_length=1, kernel_initializer=tf.orthogonal_initializer()))( x) #init=orthogonal_init x = (MaxPooling1D(pool_length=2, border_mode='valid'))(x) x = LeakyReLU(0.2)(x) # create and apply the normalizer nb = 128 / (2**l) params_before = np.sum([ np.prod(v.get_shape().as_list()) for v in tf.trainable_variables() ]) x_norm = _make_normalizer(x, nf, nb) params_after = np.sum([ np.prod(v.get_shape().as_list()) for v in tf.trainable_variables() ]) x = _apply_normalizer(x, x_norm, nf, nb) print('D-Block: {}'.format(x.get_shape())) downsampling_l.append(x) # bottleneck layer with tf.name_scope('bottleneck_conv'): x = (AtrousConvolution1D( nb_filter=n_filters[-1], filter_length=n_filtersizes[-1], atrous_rate=DRATE, activation=None, border_mode='same', subsample_length=1, kernel_initializer=tf.orthogonal_initializer()))( x) #init=orthogonal_init x = (MaxPooling1D(pool_length=2, border_mode='valid'))(x) x = Dropout(p=0.5)(x) x = LeakyReLU(0.2)(x) # create and apply the normalizer nb = 128 / (2**L) x_norm = _make_normalizer(x, n_filters[-1], nb) x = _apply_normalizer(x, x_norm, n_filters[-1], nb) print('B-Block: {}'.format(x.get_shape())) # upsampling layers for l, nf, fs, l_in in list( zip(range(L), n_filters, n_filtersizes, downsampling_l))[::-1]: with tf.name_scope('upsc_conv%d' % l): x = (AtrousConvolution1D( nb_filter=2 * nf, filter_length=fs, atrous_rate=DRATE, activation=None, border_mode='same', kernel_initializer=tf.orthogonal_initializer()))( x) #init=orthogonal_init x = Dropout(p=0.5)(x) x = Activation('relu')(x) x = SubPixel1D(x, r=2) # create and apply the normalizer x_norm = _make_normalizer(x, nf, nb) x = _apply_normalizer(x, x_norm, nf, nb) x = K.concatenate(tensors=[x, l_in], axis=2) print('U-Block: {}'.format(x.get_shape())) with tf.name_scope('lastconv'): x = Convolution1D(nb_filter=2, filter_length=9, activation=None, border_mode='same', kernel_initializer=tf.keras.initializers.normal())( x) #, init=normal_init x = SubPixel1D(x, r=2) if additive_skip_connection == True: x = tf.add(x, x_inp) return x #x è (?, 8192). // con tf.reshape(x, [-1, n_dim]) aggiungo un canale alla fine -> diventerebbe (?, 8192, 1)
def create_model(self, n_dim, r): # load inputs X, _, _ = self.inputs K.set_session(self.sess) with tf.name_scope('generator'): x = X L = self.layers n_filters = [128, 256, 512, 512, 512, 512, 512, 512] n_blocks = [128, 64, 32, 16, 8] n_filtersizes = [65, 33, 17, 9, 9, 9, 9, 9, 9] downsampling_l = [] print 'building model...' def _make_normalizer(x_in, n_filters, n_block): """applies an lstm layer on top of x_in""" x_shape = tf.shape(x_in) n_steps = x_shape[1] / n_block # will be 32 at training # first, apply standard conv layer to reduce the dimension # input of (-1, 4096, 128) becomes (-1, 32, 128) # input of (-1, 512, 512) becomes (-1, 32, 512) x_in_down = (MaxPooling1D(pool_length=n_block, border_mode='valid'))(x_in) # pooling to reduce dimension x_shape = tf.shape(x_in_down) x_rnn = LSTM(output_dim=n_filters, return_sequences=True)(x_in_down) # output: (-1, n_steps, n_filters) return x_rnn def _apply_normalizer(x_in, x_norm, n_filters, n_block): x_shape = tf.shape(x_in) n_steps = x_shape[1] / n_block # will be 32 at training # reshape input into blocks x_in = tf.reshape(x_in, shape=(-1, n_steps, n_block, n_filters)) x_norm = tf.reshape(x_norm, shape=(-1, n_steps, 1, n_filters)) # multiply x_out = x_norm * x_in # return to original shape x_out = tf.reshape(x_out, shape=x_shape) return x_out # downsampling layers for l, nf, fs in zip(range(L), n_filters, n_filtersizes): with tf.name_scope('downsc_conv%d' % l): x = (AtrousConvolution1D(nb_filter=nf, filter_length=fs, atrous_rate=DRATE, activation=None, border_mode='same', init=orthogonal_init, subsample_length=1))(x) x = (MaxPooling1D(pool_length=2, border_mode='valid'))(x) x = LeakyReLU(0.2)(x) # create and apply the normalizer nb = 128 / (2**l) params_before = np.sum([ np.prod(v.get_shape().as_list()) for v in tf.trainable_variables() ]) x_norm = _make_normalizer(x, nf, nb) params_after = np.sum([ np.prod(v.get_shape().as_list()) for v in tf.trainable_variables() ]) x = _apply_normalizer(x, x_norm, nf, nb) print 'D-Block: ', x.get_shape() downsampling_l.append(x) # bottleneck layer with tf.name_scope('bottleneck_conv'): x = (AtrousConvolution1D(nb_filter=n_filters[-1], filter_length=n_filtersizes[-1], atrous_rate=DRATE, activation=None, border_mode='same', init=orthogonal_init, subsample_length=1))(x) x = (MaxPooling1D(pool_length=2, border_mode='valid'))(x) x = Dropout(p=0.5)(x) x = LeakyReLU(0.2)(x) # create and apply the normalizer nb = 128 / (2**L) x_norm = _make_normalizer(x, n_filters[-1], nb) x = _apply_normalizer(x, x_norm, n_filters[-1], nb) # upsampling layers for l, nf, fs, l_in in reversed( zip(range(L), n_filters, n_filtersizes, downsampling_l)): with tf.name_scope('upsc_conv%d' % l): # (-1, n/2, 2f) x = (AtrousConvolution1D(nb_filter=2 * nf, filter_length=fs, atrous_rate=DRATE, activation=None, border_mode='same', init=orthogonal_init))(x) x = Dropout(p=0.5)(x) x = Activation('relu')(x) # (-1, n, f) x = SubPixel1D(x, r=2) # create and apply the normalizer x_norm = _make_normalizer(x, nf, nb) x = _apply_normalizer(x, x_norm, nf, nb) # (-1, n, 2f) x = merge([x, l_in], mode='concat', concat_axis=-1) print 'U-Block: ', x.get_shape() # final conv layer with tf.name_scope('lastconv'): x = Convolution1D(nb_filter=2, filter_length=9, activation=None, border_mode='same', init=normal_init)(x) x = SubPixel1D(x, r=2) g = merge([x, X], mode='sum') return g
def create_model(self, n_dim, r): # load inputs X, _, _ = self.inputs K.set_session(self.sess) with tf.name_scope('generator'): x = X L = self.layers # dim/layer: 4096, 2048, 1024, 512, 256, 128, 64, 32, # n_filters = [ 64, 128, 256, 384, 384, 384, 384, 384] n_filters = [ 128, 256, 512, 512, 512, 512, 512, 512] # n_filters = [ 256, 512, 512, 512, 512, 1024, 1024, 1024] # n_filtersizes = [129, 65, 33, 17, 9, 9, 9, 9] # n_filtersizes = [31, 31, 31, 31, 31, 31, 31, 31] n_filtersizes = [65, 33, 17, 9, 9, 9, 9, 9, 9] downsampling_l = [] print 'building model...' # downsampling layers for l, nf, fs in zip(range(L), n_filters, n_filtersizes): with tf.name_scope('downsc_conv%d' % l): '''x = (Convolution1D(nb_filter=nf, filter_length=fs, activation=None, border_mode='same', init=orthogonal_init, subsample_length=2))(x)''' x = Conv1D(filters=nf, kernel_size=fs, activation=None, padding='same', kernel_initializer='Orthogonal', strides=2)(x) # if l > 0: x = BatchNormalization(mode=2)(x) x = LeakyReLU(0.2)(x) print 'D-Block: ', x.get_shape() downsampling_l.append(x) # bottleneck layer with tf.name_scope('bottleneck_conv'): '''x = (Convolution1D(nb_filter=n_filters[-1], filter_length=n_filtersizes[-1], activation=None, border_mode='same', init=orthogonal_init, subsample_length=2))(x)''' x = Conv1D(filters=n_filters[-1], kernel_size=n_filtersizes[-1], activation=None, padding='same', kernel_initializer='Orthogonal', strides=2)(x) #x = Dropout(p=0.5)(x) x = Dropout(rate=0.5)(x) # x = BatchNormalization(mode=2)(x) x = LeakyReLU(0.2)(x) # upsampling layers for l, nf, fs, l_in in reversed(zip(range(L), n_filters, n_filtersizes, downsampling_l)): with tf.name_scope('upsc_conv%d' % l): # (-1, n/2, 2f) '''x = (Convolution1D(nb_filter=2*nf, filter_length=fs, activation=None, border_mode='same', init=orthogonal_init))(x)''' x = Conv1D(filters=2*nf, kernel_size=fs, activation=None, padding='same', kernel_initializer='Orthogonal')(x) # x = BatchNormalization(mode=2)(x) #x = Dropout(p=0.5)(x) x = Dropout(rate=0.5)(x) x = Activation('relu')(x) # (-1, n, f) x = SubPixel1D(x, r=2) # (-1, n, 2f) '''changed merge to new keras.layers.concact''' x = concatenate([x, l_in], axis=-1) #x = merge([x, l_in], mode='concat', concat_axis=-1) print 'U-Block: ', x.get_shape() #print 'U-Block: ', x.output_shape # final conv layer with tf.name_scope('lastconv'): '''x = Convolution1D(nb_filter=2, filter_length=9, activation=None, border_mode='same', init=normal_init)(x)''' x = Conv1D(filters=2, kernel_size=9, activation=None, padding='same', kernel_initializer='RandomNormal')(x) x = SubPixel1D(x, r=2) print x.get_shape() #g = merge([x, X], mode='sum') g = add([x, X]) return g
def unet3D(x_in, img_shape, out_im_chans, nf_enc=[64, 64, 128, 128, 256, 256, 512], nf_dec=None, regularizer=None, initializer=None, layer_prefix='unet', n_convs_per_stage=1, include_residual=False, use_maxpool=True, max_time_downsample=None, n_tasks=1, use_dropout=False, do_unpool=False, do_last_conv=True, ): ks = 3 if max_time_downsample is None: max_time_downsample = len(nf_enc) # downsample in time all the way down encoding_im_sizes = np.asarray([( int(np.ceil(img_shape[0] / 2.0 ** i)), int(np.ceil(img_shape[1] / 2.0 ** i)), int(np.ceil(img_shape[2] / 2.0 ** i)), ) for i in range(0, len(nf_enc) + 1)]) else: encoding_im_sizes = np.asarray([( int(np.ceil(img_shape[0] / 2.0 ** i)), int(np.ceil(img_shape[1] / 2.0 ** i)), max(int(np.ceil(img_shape[2] / 2.0 ** (max_time_downsample))), int(np.ceil(img_shape[2] / 2.0 ** i))), ) for i in range(0, len(nf_enc) + 1)]) reg_params = {} if regularizer == 'l1': reg = regularizers.l1(1e-6) else: reg = None if initializer == 'zeros': reg_params['kernel_initializer'] = initializers.Zeros() x = x_in encodings = [] encoding_im_sizes = [] for i in range(len(nf_enc)): if not use_maxpool and i > 0: x = LeakyReLU(0.2)(x) for j in range(n_convs_per_stage): if nf_enc[i] is not None: # in case we dont want to convovle at max resolution x = Conv3D( nf_enc[i], kernel_regularizer=reg, kernel_size=ks, strides=(1, 1, 1), padding='same', name='{}_enc_conv3D_{}_{}'.format(layer_prefix, i, j + 1))(x) #if use_dropout: # x = Dropout(0.2)(x) if j == 0 and include_residual: residual_input = x elif j == n_convs_per_stage - 1 and include_residual: x = Add()([residual_input, x]) x = LeakyReLU(0.2)(x) encodings.append(x) encoding_im_sizes.append(np.asarray(x.get_shape().as_list()[1:-1])) # only downsample if we haven't reached the max if i >= max_time_downsample: ds = (2, 2, 1) else: ds = (2, 2, 2) if i < len(nf_enc) - 1: if use_maxpool: x = MaxPooling3D(pool_size=ds, padding='same', name='{}_enc_maxpool_{}'.format(layer_prefix, i))(x) #x, pool_idxs = Lambda(lambda x:._max_pool_3d_with_argmax(x, ksize=ks, strides=(2, 2, 2), padding='same'), name='{}_enc_maxpool3dwithargmax_{}'.format(layer_prefix, i))(x) else: x = Conv3D(nf_enc[i], kernel_size=ks, strides=ds, padding='same', name='{}_enc_conv3D_{}'.format(layer_prefix, i))(x) if nf_dec is None: nf_dec = list(reversed(nf_enc[1:])) decoder_outputs = [] x_encoded = x print(encoding_im_sizes) print(nf_dec) for ti in range(n_tasks): decoding_im_sizes = [] x = x_encoded for i in range(len(nf_dec)): curr_shape = x.get_shape().as_list()[1:-1] print('Current shape {}, img shape {}'.format(x.get_shape().as_list(), img_shape)) # only do upsample if we are not yet at max resolution if np.any(curr_shape < list(img_shape[:len(curr_shape)])): # TODO: fix this for time ''' if i < len(nf_dec) - max_time_downsample + 1 \ or curr_shape[-1] >= encoding_im_sizes[-i-2][-1]: # if we are already at the correct time scale us = (2, 2, 1) else: ''' us = (2, 2, 2) #decoding_im_sizes.append(encoding_im_sizes[-i-1] * np.asarray(us)) x = UpSampling3D(size=us, name='{}_dec{}_upsamp_{}'.format(layer_prefix, ti, i))(x) # just concatenate the final layer here if i <= len(encodings) - 2: x = _pad_or_crop_to_shape_3D(x, np.asarray(x.get_shape().as_list()[1:-1]), encoding_im_sizes[-i-2]) x = Concatenate(axis=-1)([x, encodings[-i-2]]) #x = LeakyReLU(0.2)(x) residual_input = x for j in range(n_convs_per_stage): x = Conv3D(nf_dec[i], kernel_regularizer=reg, kernel_size=ks, strides=(1, 1, 1), padding='same', name='{}_dec{}_conv3D_{}_{}'.format(layer_prefix, ti, i, j))(x) if use_dropout and i < 2: x = Dropout(0.2)(x) if j == 0 and include_residual: residual_input = x elif j == n_convs_per_stage - 1 and include_residual: x = Add()([residual_input, x]) x = LeakyReLU(0.2)(x) if do_last_conv: y = Conv3D(out_im_chans, kernel_size=1, padding='same', kernel_regularizer=reg, name='{}_dec{}_conv3D_final'.format(layer_prefix, ti))(x) # add your own activation after this model else: y = x decoder_outputs.append(y) # add your own activation after this model if n_tasks == 1: return y else: return decoder_outputs
def unet2D(x_in, input_shape, out_im_chans, nf_enc=[64, 64, 128, 128, 256, 256, 512], nf_dec=None, regularizer=None, initializer=None, layer_prefix='unet', n_convs_per_stage=1, use_residuals=False, use_maxpool=False, concat_at_stages=None, do_last_conv=True, ks=3, ): reg_params = {} if regularizer == 'l1': reg = regularizers.l1(1e-6) else: reg = None if initializer == 'zeros': reg_params['kernel_initializer'] = initializers.Zeros() x = x_in encodings = [] for i in range(len(nf_enc)): if not use_maxpool and i > 0: x = LeakyReLU(0.2)(x) for j in range(n_convs_per_stage): if nf_enc[i] is not None: # in case we dont want to convolve at the first resolution x = Conv2D(nf_enc[i], kernel_regularizer=reg, kernel_size=ks, strides=(1, 1), padding='same', name='{}_enc_conv2D_{}_{}'.format(layer_prefix, i, j + 1))(x) if concat_at_stages and concat_at_stages[i] is not None: x = Concatenate(axis=-1)([x, concat_at_stages[i]]) if j == 0 and use_residuals: residual_input = x elif j == n_convs_per_stage - 1 and use_residuals: x = Add()([residual_input, x]) x = LeakyReLU(0.2)(x) if i < len(nf_enc) - 1: encodings.append(x) if use_maxpool: x = MaxPooling2D(pool_size=(2, 2), padding='same', name='{}_enc_maxpool_{}'.format(layer_prefix, i))(x) else: x = Conv2D(nf_enc[i], kernel_size=ks, strides=(2, 2), padding='same', name='{}_enc_conv2D_{}'.format(layer_prefix, i))(x) print('Encodings to concat later: {}'.format(encodings)) if nf_dec is None: nf_dec = list(reversed(nf_enc[1:])) print('Decoder channels: {}'.format(nf_dec)) for i in range(len(nf_dec)): curr_shape = x.get_shape().as_list()[1:-1] # if we're not at full resolution, keep upsampling if np.any(list(curr_shape[:2]) < list(input_shape[:2])): x = UpSampling2D(size=(2, 2), name='{}_dec_upsamp_{}'.format(layer_prefix, i))(x) # if we still have things to concatenate, do that if (i + 1) <= len(encodings): curr_shape = x.get_shape().as_list()[1:-1] concat_with_shape = encodings[-i - 1].get_shape().as_list()[1:-1] x = _pad_or_crop_to_shape(x, curr_shape, concat_with_shape) x = Concatenate()([x, encodings[-i - 1]]) residual_input = x for j in range(n_convs_per_stage): x = Conv2D(nf_dec[i], kernel_regularizer=reg, kernel_size=ks, strides=(1, 1), padding='same', name='{}_dec_conv2D_{}_{}'.format(layer_prefix, i, j))(x) if j == 0 and use_residuals: residual_input = x elif j == n_convs_per_stage - 1 and use_residuals: x = Add()([residual_input, x]) x = LeakyReLU(0.2)(x) #x = Concatenate()([x, encodings[0]]) ''' for j in range(n_convs_per_stage - 1): x = Conv2D(out_im_chans, kernel_regularizer=reg, kernel_size=ks, strides=(1, 1), padding='same', name='{}_dec_conv2D_last_{}'.format(layer_prefix, j))(x) x = LeakyReLU(0.2)(x) ''' if do_last_conv: y = Conv2D(out_im_chans, kernel_size=1, padding='same', kernel_regularizer=reg, name='{}_dec_conv2D_final'.format(layer_prefix))(x) # add your own activation after this model else: y = x # add your own activation after this model return y
def create_model(self, n_dim, r): # load inputs X, _, _ = self.inputs tf.compat.v1.keras.backend.set_session(self.sess) with tf.name_scope('generator'): x = X L = self.layers # dim/layer: 4096, 2048, 1024, 512, 256, 128, 64, 32, # n_filters = [ 64, 128, 256, 384, 384, 384, 384, 384] n_filters = [128, 256, 512, 512, 512, 512, 512, 512] # n_filters = [ 256, 512, 512, 512, 512, 1024, 1024, 1024] # n_filtersizes = [129, 65, 33, 17, 9, 9, 9, 9] # n_filtersizes = [31, 31, 31, 31, 31, 31, 31, 31] n_filtersizes = [65, 33, 17, 9, 9, 9, 9, 9, 9] downsampling_l = [] print('building model...') # downsampling layers for l, nf, fs in zip(range(L), n_filters, n_filtersizes): with tf.name_scope('downsc_conv%d' % l): x = (Conv1D(filters=nf, kernel_size=fs, activation=None, padding='same', kernel_initializer="Orthogonal", strides=2))(x) # if l > 0: x = BatchNormalization(mode=2)(x) x = LeakyReLU(0.2)(x) print('D-Block: ', x.get_shape()) downsampling_l.append(x) # bottleneck layer with tf.name_scope('bottleneck_conv'): x = (Conv1D(filters=n_filters[-1], kernel_size=n_filtersizes[-1], activation=None, padding='same', kernel_initializer="Orthogonal", strides=2))(x) x = Dropout(rate=0.5)(x) # x = BatchNormalization(mode=2)(x) x = LeakyReLU(0.2)(x) # upsampling layers for l, nf, fs, l_in in reversed( list( zip(range(L), n_filters, n_filtersizes, downsampling_l))): with tf.name_scope('upsc_conv%d' % l): # (-1, n/2, 2f) x = (Conv1D(filters=2 * nf, kernel_size=fs, activation=None, padding='same', kernel_initializer="Orthogonal"))(x) # x = BatchNormalization(mode=2)(x) x = Dropout(rate=0.5)(x) x = Activation('relu')(x) # (-1, n, f) x = SubPixel1D(x, r=2) x = Concatenate(axis=-1)([x, l_in]) # (-1, n, 2f) print('U-Block: ', x.get_shape()) # final conv layer with tf.name_scope('lastconv'): x = Conv1D(filters=2, kernel_size=9, activation=None, padding='same', kernel_initializer=normal_init)(x) x = SubPixel1D(x, r=2) print(x.get_shape()) g = add([x, X]) return g