def __init__( self, input_width, input_height, input_channels, hidden_sizes, activation="relu", activation_out="logsoftmax", n_out=2, ): super(FCNClassifierModel, self).__init__() self.input_width = input_width self.input_height = input_height self.input_channels = input_channels self.hidden_sizes = hidden_sizes self.fc_activations = [activation for i in range(len(hidden_sizes)) ] + [activation_out] self.n_out = n_out # get flattend input size x = torch.randn(self.input_channels, self.input_width, self.input_height).view(-1, self.input_channels, self.input_width, self.input_height) self._to_linear = x[0].shape[0] * x[0].shape[1] * x[0].shape[2] # define fully connected layers fc_args = dict(input_size=self._to_linear, hidden_sizes=self.hidden_sizes, output_size=self.n_out, activations=self.fc_activations) fc_parameters = u.get_fc_layers(**fc_args) self.fc_layers = u.build_layers(fc_parameters)
def __init__( self, input_width, input_height, input_channels, hidden_sizes, activation="relu", activation_out="relu", ): super(FCAutoencoderModel, self).__init__() self.input_width = input_width self.input_height = input_height self.input_channels = input_channels self.hidden_sizes = hidden_sizes self.fc_encoder_activations = [ activation for i in range(len(hidden_sizes)) ] self.fc_decoder_activations = [ activation for i in range(len(hidden_sizes) - 1) ] + [activation_out] # get flattend input size x = torch.randn(self.input_channels, self.input_width, self.input_height).view(-1, self.input_channels, self.input_width, self.input_height) self._to_linear = x[0].shape[0] * x[0].shape[1] * x[0].shape[2] # define fully connected layers fc_encoder_args = dict(input_size=self._to_linear, hidden_sizes=self.hidden_sizes[:-1], output_size=self.hidden_sizes[-1], activations=self.fc_encoder_activations) fc_encoder_parameters = u.get_fc_layers(**fc_encoder_args) self.fc_encoder_layers = u.build_layers(fc_encoder_parameters) decoder_sizes = self.hidden_sizes[:-1] decoder_sizes.reverse() fc_decoder_args = dict(input_size=self.hidden_sizes[-1], hidden_sizes=decoder_sizes, output_size=self._to_linear, activations=self.fc_decoder_activations) fc_decoder_parameters = u.get_fc_layers(**fc_decoder_args) self.fc_decoder_layers = u.build_layers(fc_decoder_parameters)
def __init__( self, input_width, input_height, input_channels, hidden_sizes, activation="lif", activation_out="lif", steps=100, threshold=1, decay=0.99, n_out=2, device="cuda", ): super(SFCNModel, self).__init__() self.input_width = input_width self.input_height = input_height self.input_channels = input_channels self.hidden_sizes = hidden_sizes self.fc_activations = [activation for i in range(len(hidden_sizes))] + [activation_out] self.n_out = n_out self.device = device self.steps = steps # get flattend input size x = torch.randn(self.input_channels, self.input_width, self.input_height).view( -1, self.input_channels, self.input_width, self.input_height ) self._to_linear = x[0].shape[0] * x[0].shape[1] * x[0].shape[2] # define fully connected layers fc_args = dict( input_size=self._to_linear, hidden_sizes=self.hidden_sizes, output_size=self.n_out, activations=self.fc_activations, thresholds=[threshold for i in range(len(self.fc_activations))], decays=[decay for i in range(len(self.fc_activations))], ) fc_parameters = u.get_sfc_layers(**fc_args) self.fc_layers = u.build_layers(fc_parameters)
def __init__( self, input_width, input_height, input_channels, conv2d_channels, hidden_sizes, kernel_sizes, strides, paddings, #pooling_kernels, #pooling_strides, #activation="lif", #activation_out="lif", pooling="avg", steps=100, threshold=1, decay=0.99, adapt_threshold=True, threshold_width=0.1, delta_threshold=0.0001, rho=0.0001, epsilon=0.05, inactivity_threshold=0, delta_w=0.01, #pool_threshold=0.75, encoder_params={"encoder": "first"}, decoder_params={"decoder": "max"}, device="cuda", reset=True, ): super(SCNNAutoencoderModelNew, self).__init__() self.input_width = input_width self.input_height = input_height self.input_channels = input_channels self.conv2d_channels = conv2d_channels self.kernel_sizes = kernel_sizes self.strides = strides self.paddings = paddings #self.pooling_kernels = pooling_kernels #self.pooling_strides = pooling_strides self.hidden_sizes = hidden_sizes self.device = device self.steps = steps self.reset = reset print(adapt_threshold) # define convolutional encoder layers sconv_encoder_args = dict( input_channels=self.input_channels, channels=self.conv2d_channels, kernel_sizes=self.kernel_sizes, strides=self.strides, paddings=self.paddings, #activations=[activation for i in range(len(self.conv2d_channels))], #pooling_funcs=[pooling for i in range(len(self.conv2d_channels))], #pooling_kernels=self.pooling_kernels, #pooling_strides=self.pooling_strides, thresholds=[threshold for i in range(len(self.conv2d_channels))], decays=[decay for i in range(len(self.conv2d_channels))], adapt_thresh=adapt_threshold, threshold_widths=[threshold_width for i in range(len(self.conv2d_channels))], delta_thresholds=[delta_threshold for i in range(len(self.conv2d_channels))], rhos=[rho for i in range(len(self.conv2d_channels))], epsilons=[epsilon for i in range(len(self.conv2d_channels))], inactivity_thresholds=[inactivity_threshold for i in range(len(self.conv2d_channels))], delta_ws=[delta_w for i in range(len(self.conv2d_channels))], device=self.device, reset=self.reset, #pool_thresholds=[pool_threshold for i in range(len(self.conv2d_channels))], ) sconv_encoder_parameters = u.get_sconv2dlif_layers(**sconv_encoder_args) self.conv_encoder_layers = u.build_layers(sconv_encoder_parameters).to(self.device) # get flattend input size x = torch.randn(self.input_channels, self.input_width, self.input_height).view( -1, self.input_channels, self.input_width, self.input_height ).to(self.device) x_ = self.conv_encode(x) self._to_linear = x_[0].shape[0] * x_[0].shape[1] * x_[0].shape[2] self._from_linear = (x_[0].shape[0], x_[0].shape[1], x_[0].shape[2]) # define fully connected encoder layers #self.fc_encoder_activations = [activation for i in range(len(hidden_sizes))] sfc_encoder_args = dict( input_size=self._to_linear, hidden_sizes=self.hidden_sizes[:-1], output_size=self.hidden_sizes[-1], #activations=self.fc_encoder_activations, thresholds=[threshold for i in range(len(self.hidden_sizes))], decays=[decay for i in range(len(self.hidden_sizes))], adapt_thresh=adapt_threshold, threshold_widths=[threshold_width for i in range(len(self.hidden_sizes))], delta_thresholds=[delta_threshold for i in range(len(self.hidden_sizes))], rhos=[rho for i in range(len(self.hidden_sizes))], inactivity_thresholds=[inactivity_threshold for i in range(len(self.hidden_sizes))], delta_ws=[delta_w for i in range(len(self.hidden_sizes))], epsilons=[epsilon for i in range(len(self.hidden_sizes))], device=self.device, reset=self.reset, ) sfc_encoder_parameters = u.get_sfclif_layers(**sfc_encoder_args) self.fc_encoder_layers = u.build_layers(sfc_encoder_parameters) # define fully connected decoder layers #self.fc_decoder_activations = [activation for i in range(len(hidden_sizes))] decoder_sizes = self.hidden_sizes[:-1] decoder_sizes.reverse() sfc_decoder_args = dict( input_size=self.hidden_sizes[-1], hidden_sizes=decoder_sizes, output_size=self._to_linear, #activations=self.fc_decoder_activations, thresholds=[threshold for i in range(len(self.hidden_sizes))], decays=[decay for i in range(len(self.hidden_sizes))], adapt_thresh=adapt_threshold, threshold_widths=[threshold_width for i in range(len(self.hidden_sizes))], delta_thresholds=[delta_threshold for i in range(len(self.hidden_sizes))], rhos=[rho for i in range(len(self.hidden_sizes))], epsilons=[epsilon for i in range(len(self.hidden_sizes))], inactivity_thresholds=[inactivity_threshold for i in range(len(self.hidden_sizes))], delta_ws=[delta_w for i in range(len(self.hidden_sizes))], device=self.device, reset=self.reset, ) sfc_decoder_parameters = u.get_sfclif_layers(**sfc_decoder_args) self.fc_decoder_layers = u.build_layers(sfc_decoder_parameters) # define convolutional decoder layers decoder_kernel_sizes = self.kernel_sizes decoder_kernel_sizes.reverse() decoder_convtranspose2d_channels = [self.input_channels] + self.conv2d_channels[:-1] decoder_convtranspose2d_channels.reverse() decoder_strides = self.strides decoder_strides.reverse() decoder_paddings = self.paddings decoder_paddings.reverse() #unpooling_kernels = self.pooling_kernels #unpooling_kernels.reverse() #unpooling_strides = self.pooling_strides #unpooling_strides.reverse() print(adapt_threshold) sconv_decoder_args = dict( input_channels=x_[0].shape[0], channels=decoder_convtranspose2d_channels, kernel_sizes=decoder_kernel_sizes, strides=decoder_strides, paddings=decoder_paddings, #activations=[activation for i in range(len(self.conv2d_channels) - 1)] + [activation_out], #unpooling_funcs=[pooling for i in range(len(self.conv2d_channels))], #unpooling_kernels=unpooling_kernels, #unpooling_strides=unpooling_strides, thresholds=[threshold for i in range(len(self.conv2d_channels))], decays=[decay for i in range(len(self.conv2d_channels))], adapt_thresh=adapt_threshold, threshold_widths=[threshold_width for i in range(len(self.conv2d_channels))], delta_thresholds=[delta_threshold for i in range(len(self.conv2d_channels))], rhos=[rho for i in range(len(self.conv2d_channels))], epsilons=[epsilon for i in range(len(self.conv2d_channels))], inactivity_thresholds=[inactivity_threshold for i in range(len(self.conv2d_channels))], delta_ws=[delta_w for i in range(len(self.conv2d_channels))], device=self.device, reset=self.reset, #pool_thresholds=[pool_threshold for i in range(len(self.conv2d_channels))], ) sconv_decoder_parameters = u.get_sconvtranspose2dlif_layers(**sconv_decoder_args) self.conv_decoder_layers = u.build_layers(sconv_decoder_parameters) # initialize input encoder self.input_encoder = get_input_encoder(**encoder_params) # initialize output decoder self.output_decoder = get_output_decoder(**decoder_params)
def __init__( self, input_width, input_height, input_channels, conv2d_channels, hidden_sizes, kernel_sizes, strides, paddings, pooling_kernels, pooling_strides, encoder_params={"encoder": "noisy"}, activation="relu", activation_out="logsoftmax", pooling="avg", ): super(CNNAutoencoderModel, self).__init__() self.input_width = input_width self.input_height = input_height self.input_channels = input_channels self.conv2d_channels = conv2d_channels self.kernel_sizes = kernel_sizes self.strides = strides self.paddings = paddings self.pooling_kernels = pooling_kernels self.pooling_strides = pooling_strides self.hidden_sizes = hidden_sizes # self.fc_activations = [activation for i in range(len(hidden_sizes))] + [activation_out] # define convolutional encoder layers conv_encoder_args = dict( input_channels=self.input_channels, channels=self.conv2d_channels, kernel_sizes=self.kernel_sizes, strides=self.strides, paddings=self.paddings, activations=[activation for i in range(len(self.conv2d_channels))], pooling_funcs=[pooling for i in range(len(self.conv2d_channels))], pooling_kernels=self.pooling_kernels, pooling_strides=self.pooling_strides, ) conv_encoder_parameters = u.get_conv2d_layers(**conv_encoder_args) self.conv_encoder_layers = u.build_layers(conv_encoder_parameters) # get flattend input size and reverse transformation x = torch.randn(self.input_channels, self.input_width, self.input_height).view( -1, self.input_channels, self.input_width, self.input_height ) x_ = self.conv_encode(x) self._to_linear = x_[0].shape[0] * x_[0].shape[1] * x_[0].shape[2] self._from_linear = (x_[0].shape[0], x_[0].shape[1], x_[0].shape[2]) # define fully connected encoder layers self.fc_encoder_activations = [activation for i in range(len(hidden_sizes))] fc_encoder_args = dict( input_size=self._to_linear, hidden_sizes=self.hidden_sizes[:-1], output_size=self.hidden_sizes[-1], activations=self.fc_encoder_activations, ) fc_encoder_parameters = u.get_fc_layers(**fc_encoder_args) self.fc_encoder_layers = u.build_layers(fc_encoder_parameters) # define fully connected decoder layers self.fc_decoder_activations = [activation for i in range(len(hidden_sizes))] decoder_sizes = self.hidden_sizes[:-1] decoder_sizes.reverse() fc_decoder_args = dict( input_size=self.hidden_sizes[-1], hidden_sizes=decoder_sizes, output_size=self._to_linear, activations=self.fc_decoder_activations, ) fc_decoder_parameters = u.get_fc_layers(**fc_decoder_args) self.fc_decoder_layers = u.build_layers(fc_decoder_parameters) # define convolutional decoder layers decoder_kernel_sizes = self.kernel_sizes decoder_kernel_sizes.reverse() decoder_convtranspose2d_channels = [self.input_channels] + self.conv2d_channels[:-1] decoder_convtranspose2d_channels.reverse() decoder_strides = self.strides decoder_strides.reverse() decoder_paddings = self.paddings decoder_paddings.reverse() unpooling_kernels = self.pooling_kernels unpooling_kernels.reverse() unpooling_strides = self.pooling_strides unpooling_strides.reverse() conv_decoder_args = dict( input_channels=x_[0].shape[0], channels=decoder_convtranspose2d_channels, kernel_sizes=decoder_kernel_sizes, strides=decoder_strides, paddings=decoder_paddings, activations=[activation for i in range(len(self.conv2d_channels) - 1)] + [activation_out], unpooling_funcs=[pooling for i in range(len(self.conv2d_channels))], unpooling_kernels=unpooling_kernels, unpooling_strides=unpooling_strides, ) conv_decoder_parameters = u.get_convtranspose2d_layers(**conv_decoder_args) self.conv_decoder_layers = u.build_layers(conv_decoder_parameters) # initialize input encoder self.input_encoder = get_input_encoder(**encoder_params)
def __init__( self, input_width, input_height, input_channels, conv2d_channels, hidden_sizes, kernel_sizes, strides, paddings, pooling_kernels, pooling_strides, activation="relu", activation_out="logsoftmax", pooling="avg", n_out=2, ): super(CNNModel, self).__init__() self.input_width = input_width self.input_height = input_height self.input_channels = input_channels self.conv2d_channels = conv2d_channels self.kernel_sizes = kernel_sizes self.strides = strides self.paddings = paddings self.pooling_kernels = pooling_kernels self.pooling_strides = pooling_strides self.hidden_sizes = hidden_sizes self.fc_activations = [activation for i in range(len(hidden_sizes)) ] + [activation_out] self.n_out = n_out # define convolutional layers conv_args = dict( input_channels=self.input_channels, channels=self.conv2d_channels, kernel_sizes=self.kernel_sizes, strides=self.strides, activations=[activation for i in range(len(self.conv2d_channels))], pooling_funcs=[pooling for i in range(len(self.conv2d_channels))], pooling_kernels=self.pooling_kernels, pooling_strides=self.pooling_strides, ) conv_parameters = u.get_conv2d_layers(**conv_args) self.conv_layers = u.build_layers(conv_parameters) # get flattend input size x = torch.randn(self.input_channels, self.input_width, self.input_height).view(-1, self.input_channels, self.input_width, self.input_height) x_ = self.convs(x) self._to_linear = x_[0].shape[0] * x_[0].shape[1] * x_[0].shape[2] # define fully connected layers fc_args = dict(input_size=self._to_linear, hidden_sizes=self.hidden_sizes, output_size=self.n_out, activations=self.fc_activations) fc_parameters = u.get_fc_layers(**fc_args) self.fc_layers = u.build_layers(fc_parameters)
def __init__( self, input_width, input_height, input_channels, conv2d_channels, hidden_sizes, kernel_sizes, strides, paddings, pooling_kernels, pooling_strides, activation="lif", activation_out="lif", pooling="avg", steps=100, threshold=1, decay=0.99, pool_threshold=0.75, n_out=2, device="cuda", ): super(SCNNModel, self).__init__() self.input_width = input_width self.input_height = input_height self.input_channels = input_channels self.conv2d_channels = conv2d_channels self.kernel_sizes = kernel_sizes self.strides = strides self.paddings = paddings self.pooling_kernels = pooling_kernels self.pooling_strides = pooling_strides self.hidden_sizes = hidden_sizes self.fc_activations = [activation for i in range(len(hidden_sizes)) ] + [activation_out] self.n_out = n_out self.device = device self.steps = steps # define convolutional layers conv_args = dict( input_channels=self.input_channels, channels=self.conv2d_channels, kernel_sizes=self.kernel_sizes, strides=self.strides, paddings=self.paddings, activations=[activation for i in range(len(self.conv2d_channels))], pooling_funcs=[pooling for i in range(len(self.conv2d_channels))], pooling_kernels=self.pooling_kernels, pooling_strides=self.pooling_strides, thresholds=[threshold for i in range(len(self.conv2d_channels))], decays=[decay for i in range(len(self.conv2d_channels))], pool_thresholds=[ pool_threshold for i in range(len(self.conv2d_channels)) ], ) sconv_parameters = u.get_sconv2d_layers(**conv_args) self.conv_layers = u.build_layers(sconv_parameters) # get flattend input size x = torch.randn(self.input_channels, self.input_width, self.input_height).view(-1, self.input_channels, self.input_width, self.input_height) x_ = self.convs(x) self._to_linear = x_[0].shape[0] * x_[0].shape[1] * x_[0].shape[2] # define fully connected layers fc_args = dict( input_size=self._to_linear, hidden_sizes=self.hidden_sizes, output_size=self.n_out, activations=self.fc_activations, thresholds=[threshold for i in range(len(self.fc_activations))], decays=[decay for i in range(len(self.fc_activations))], ) fc_parameters = u.get_sfc_layers(**fc_args) self.fc_layers = u.build_layers(fc_parameters)