我们从Python开源项目中，提取了以下26个代码示例，用于说明如何使用keras.engine.topology.InputSpec()。
def __init__(self, **kwargs): self.init = initializations.get('normal') #self.input_spec = [InputSpec(ndim=3)] super(AttLayer, self).__init__(**kwargs)
def build(self, input_shape): assert len(input_shape)==3 #self.W = self.init((input_shape[-1],1)) self.W = self.init((input_shape[-1],)) #self.input_spec = [InputSpec(shape=input_shape)] self.trainable_weights = [self.W] super(AttLayer, self).build(input_shape) # be sure you call this somewhere!
def __init__(self, **kwargs): super(EmbeddingAveragePooling, self).__init__(**kwargs) self.input_spec = [InputSpec(ndim=3)] self.supports_masking = True
def build(self, input_shape): self.input_spec = [InputSpec(shape=input_shape)] shape = (input_shape[self.axis],) init_gamma = self.scale * np.ones(shape) self.gamma = K.variable(init_gamma, name='{}_gamma'.format(self.name)) self.trainable_weights = [self.gamma]
def __init__(self, n_clusters, weights=None, alpha=1.0, **kwargs): if 'input_shape' not in kwargs and 'input_dim' in kwargs: kwargs['input_shape'] = (kwargs.pop('input_dim'),) super(ClusteringLayer, self).__init__(**kwargs) self.n_clusters = n_clusters self.alpha = alpha self.initial_weights = weights self.input_spec = InputSpec(ndim=2)
def build(self, input_shape): assert len(input_shape) == 2 input_dim = input_shape[1] self.input_spec = InputSpec(dtype=K.floatx(), shape=(None, input_dim)) self.clusters = self.add_weight((self.n_clusters, input_dim), initializer='glorot_uniform', name='clusters') if self.initial_weights is not None: self.set_weights(self.initial_weights) del self.initial_weights self.built = True
def build(self, input_shape): bs, input_length, input_dim = input_shape self.controller_input_dim, self.controller_output_dim = controller_input_output_shape( input_dim, self.units, self.m_depth, self.n_slots, self.shift_range, self.read_heads, self.write_heads) # Now that we've calculated the shape of the controller, we have add it to the layer/model. if self.controller is None: self.controller = Dense( name = "controller", activation = 'linear', bias_initializer = 'zeros', units = self.controller_output_dim, input_shape = (bs, input_length, self.controller_input_dim)) self.controller.build(input_shape=(self.batch_size, input_length, self.controller_input_dim)) self.controller_with_state = False # This is a fixed shift matrix self.C = _circulant(self.n_slots, self.shift_range) self.trainable_weights = self.controller.trainable_weights # We need to declare the number of states we want to carry around. # In our case the dimension seems to be 6 (LSTM) or 5 (GRU) or 4 (FF), # see self.get_initial_states, those respond to: # [old_ntm_output] + [init_M, init_wr, init_ww] + [init_h] (LSMT and GRU) + [(init_c] (LSTM only)) # old_ntm_output does not make sense in our world, but is required by the definition of the step function we # intend to use. # WARNING: What self.state_spec does is only poorly understood, # I only copied it from keras/recurrent.py. self.states = [None, None, None, None] self.state_spec = [InputSpec(shape=(None, self.output_dim)), # old_ntm_output InputSpec(shape=(None, self.n_slots, self.m_depth)), # Memory InputSpec(shape=(None, self.read_heads, self.n_slots)), # weights_read InputSpec(shape=(None, self.write_heads, self.n_slots))] # weights_write super(NeuralTuringMachine, self).build(input_shape)
def build(self, input_shape): input_dim = input_shape[1] self.input_spec = [InputSpec(dtype=K.floatx(), shape=(None, input_dim))] self.W = self.init((input_dim, self.output_dim), name='{}_W'.format(self.name)) self.trainable_weights = [self.W] if self.initial_weights is not None: self.set_weights(self.initial_weights) del self.initial_weights
def build(self, input_shape): self.input_spec = [InputSpec(shape=input_shape)] if self.stateful: self.reset_states() else: self.states = [K.random_normal(shape=(self.output_dim,), mean=0.5, std=0.5)] input_dim = input_shape[2] self.input_dim = input_dim self.W = self.init((input_dim, self.output_dim), name='{}_W'.format(self.name)) self.U = self.inner_init((self.output_dim, self.output_dim), name='{}_U'.format(self.name)) self.b = K.zeros((self.output_dim,), name='{}_b'.format(self.name)) self.regularizers = [] if self.W_regularizer: self.W_regularizer.set_param(self.W) self.regularizers.append(self.W_regularizer) if self.U_regularizer: self.U_regularizer.set_param(self.U) self.regularizers.append(self.U_regularizer) if self.b_regularizer: self.b_regularizer.set_param(self.b) self.regularizers.append(self.b_regularizer) self.trainable_weights = [self.W, self.U] if self.dale_ratio: self.non_trainable_weights = [self.Dale] if self.initial_weights is not None: self.set_weights(self.initial_weights) del self.initial_weights
def __init__(self, output_dim, init='glorot_uniform', activation='linear', weights=None, W_regularizer=None, b_regularizer=None, activity_regularizer=None, W_constraint=None, b_constraint=None, bias=False, input_dim=None, dale_ratio = .8, **kwargs): self.init = initializations.get(init) self.activation = activations.get(activation) self.output_dim = output_dim self.input_dim = input_dim self.W_regularizer = regularizers.get(W_regularizer) self.b_regularizer = regularizers.get(b_regularizer) self.activity_regularizer = regularizers.get(activity_regularizer) self.W_constraint = constraints.get(W_constraint) self.b_constraint = constraints.get(b_constraint) self.bias = bias self.initial_weights = weights self.input_spec = [InputSpec(ndim=2)] # OUR CHANGE self.dale_ratio = dale_ratio if dale_ratio: dale_vec = np.ones((input_dim, 1)) dale_vec[int(dale_ratio*input_dim):, 0] = 0 self.Dale = K.variable(dale_vec) if self.input_dim: kwargs['input_shape'] = (self.input_dim,) super(Dense, self).__init__(**kwargs)
def build(self, input_shape): self.input_spec = [InputSpec(shape=input_shape)] super(AnchorBoxes3D, self).build(input_shape)
def build(self, input_shape): self.input_spec = [InputSpec(shape=input_shape)] gamma = self.gamma_init * np.ones((input_shape[self.axis],)) self.gamma = K.variable(gamma, name='{}_gamma'.format(self.name)) self.trainable_weights = [self.gamma] super(L2Normalization, self).build(input_shape)
def build(self, input_shape): self.input_spec = [InputSpec(shape=input_shape)] super(AnchorBoxes, self).build(input_shape)
def build(self, input_shape): self.input_spec = [InputSpec(shape=input_shape)] self.input_dim = input_shape[-1] self.kernel = self.add_weight((self.input_dim, self.units), name='kernel', initializer=self.kernel_initializer, regularizer=self.kernel_regularizer, constraint=self.kernel_constraint) self.chain_kernel = self.add_weight((self.units, self.units), name='chain_kernel', initializer=self.chain_initializer, regularizer=self.chain_regularizer, constraint=self.chain_constraint) if self.use_bias: self.bias = self.add_weight((self.units,), name='bias', initializer=self.bias_initializer, regularizer=self.bias_regularizer, constraint=self.bias_constraint) else: self.bias = None if self.use_boundary: self.left_boundary = self.add_weight((self.units,), name='left_boundary', initializer=self.boundary_initializer, regularizer=self.boundary_regularizer, constraint=self.boundary_constraint) self.right_boundary = self.add_weight((self.units,), name='right_boundary', initializer=self.boundary_initializer, regularizer=self.boundary_regularizer, constraint=self.boundary_constraint) self.built = True
def __init__(self, output_dim, input_dim=None, weights=None, alpha=1.0, **kwargs): self.output_dim = output_dim self.input_dim = input_dim self.alpha = alpha # kmeans cluster centre locations self.initial_weights = weights self.input_spec = [InputSpec(ndim=2)] if self.input_dim: kwargs['input_shape'] = (self.input_dim,) super(ClusteringLayer, self).__init__(**kwargs)
def build(self, input_shape): assert len(input_shape) == 2 input_dim = input_shape[1] self.input_spec = [InputSpec(dtype=K.floatx(), shape=(None, input_dim))] self.W = K.variable(self.initial_weights) self.trainable_weights = [self.W]
def build(self, input_shape): assert len(input_shape) == 2 input_dim = input_shape[1] self.input_spec = [InputSpec(dtype=K.floatx(), shape=(None, input_dim))] self.W = self.init((input_dim, self.output_dim), name='{}_W'.format(self.name)) if self.bias: self.b = K.zeros((self.output_dim,), name='{}_b'.format(self.name)) self.trainable_weights = [self.W, self.b] else: self.trainable_weights = [self.W] self.regularizers = [] if self.W_regularizer: self.W_regularizer.set_param(self.W) self.regularizers.append(self.W_regularizer) if self.bias and self.b_regularizer: self.b_regularizer.set_param(self.b) self.regularizers.append(self.b_regularizer) if self.activity_regularizer: self.activity_regularizer.set_layer(self) self.regularizers.append(self.activity_regularizer) #OUR CHANGE if self.dale_ratio: self.non_trainable_weights = [self.Dale] self.constraints = {} if self.W_constraint: self.constraints[self.W] = self.W_constraint if self.bias and self.b_constraint: self.constraints[self.b] = self.b_constraint if self.initial_weights is not None: self.set_weights(self.initial_weights) del self.initial_weights self.built = True
def build(self, input_shape): self.input_spec = [InputSpec(shape=input_shape)] self.input_dim = input_shape[2] if self.stateful: self.reset_states() else: # initial states: all-zero tensor of shape (output_dim) self.states = [None] if self.consume_less == 'gpu': self.W = self.add_weight((self.input_dim, 2 * self.output_dim), initializer=self.init, name='{}_W'.format(self.name), regularizer=self.W_regularizer) self.U = self.add_weight((self.output_dim, 2 * self.output_dim), initializer=self.inner_init, name='{}_U'.format(self.name), regularizer=self.U_regularizer) self.b = self.add_weight((self.output_dim * 2,), initializer='zero', name='{}_b'.format(self.name), regularizer=self.b_regularizer) else: self.W_f = self.add_weight((self.input_dim, self.output_dim), initializer=self.init, name='{}_W_z'.format(self.name), regularizer=self.W_regularizer) self.U_f = self.add_weight((self.output_dim, self.output_dim), initializer=self.init, name='{}_U_z'.format(self.name), regularizer=self.W_regularizer) self.b_f = self.add_weight((self.output_dim,), initializer='zero', name='{}_b_z'.format(self.name), regularizer=self.b_regularizer) self.W_h = self.add_weight((self.input_dim, self.output_dim), initializer=self.init, name='{}_W_h'.format(self.name), regularizer=self.W_regularizer) self.U_h = self.add_weight((self.output_dim, self.output_dim), initializer=self.init, name='{}_U_h'.format(self.name), regularizer=self.W_regularizer) self.b_h = self.add_weight((self.output_dim,), initializer='zero', name='{}_b_h'.format(self.name), regularizer=self.b_regularizer) self.W = K.concatenate([self.W_f, self.W_h]) self.U = K.concatenate([self.U_f, self.U_h]) self.b = K.concatenate([self.b_f, self.b_h]) if self.initial_weights is not None: self.set_weights(self.initial_weights) del self.initial_weights self.built = True
