def weights_init_xavier(m):
classname = m.__class__.__name__
# print(classname)
if classname.find('Conv') != -1:
init.xavier_normal(m.weight.data, gain=0.02)
elif classname.find('Linear') != -1:
init.xavier_normal(m.weight.data, gain=0.02)
elif classname.find('BatchNorm2d') != -1:
init.normal(m.weight.data, 1.0, 0.02)
init.constant(m.bias.data, 0.0)
python类xavier_normal()的实例源码
def reset_parameters(self):
for i in range(self.n_feats):
embeddings = getattr(self, "embeddings_{}".format(i))
I.xavier_normal(embeddings.weight.data)
I.xavier_normal(self.input_layer.weight.data)
I.xavier_normal(self.output_layer.weight.data)
self.crf.reset_parameters()
self.lstm.reset_parameters()
def _initialize_weights(self, layer):
init.xavier_normal(layer.weight)
def __init__(self):
super(C3D, self).__init__()
self.group1 = nn.Sequential(
nn.Conv3d(3, 64, kernel_size=3, padding=1),
nn.ReLU(),
nn.MaxPool3d(kernel_size=(1, 2, 2), stride=(1, 2, 2)))
#init.xavier_normal(self.group1.state_dict()['weight'])
self.group2 = nn.Sequential(
nn.Conv3d(64, 128, kernel_size=3, padding=1),
nn.ReLU(),
nn.MaxPool3d(kernel_size=(2, 2, 2), stride=(2, 2, 2)))
#init.xavier_normal(self.group2.state_dict()['weight'])
self.group3 = nn.Sequential(
nn.Conv3d(128, 256, kernel_size=3, padding=1),
nn.ReLU(),
nn.Conv3d(256, 256, kernel_size=3, padding=1),
nn.ReLU(),
nn.MaxPool3d(kernel_size=(2, 2, 2), stride=(2, 2, 2)))
#init.xavier_normal(self.group3.state_dict()['weight'])
self.group4 = nn.Sequential(
nn.Conv3d(256, 512, kernel_size=3, padding=1),
nn.ReLU(),
nn.Conv3d(512, 512, kernel_size=3, padding=1),
nn.ReLU(),
nn.MaxPool3d(kernel_size=(2, 2, 2), stride=(2, 2, 2)))
#init.xavier_normal(self.group4.state_dict()['weight'])
self.group5 = nn.Sequential(
nn.Conv3d(512, 512, kernel_size=3, padding=1),
nn.ReLU(),
nn.Conv3d(512, 512, kernel_size=3, padding=1),
nn.ReLU(),
nn.MaxPool3d(kernel_size=(2, 2, 2), stride=(2, 2, 2)))
#init.xavier_normal(self.group5.state_dict()['weight'])
self.fc1 = nn.Sequential(
nn.Linear(512 * 3 * 3, 2048), #
nn.ReLU(),
nn.Dropout(0.5))
#init.xavier_normal(self.fc1.state_dict()['weight'])
self.fc2 = nn.Sequential(
nn.Linear(2048, 2048),
nn.ReLU(),
nn.Dropout(0.5))
#init.xavier_normal(self.fc2.state_dict()['weight'])
self.fc3 = nn.Sequential(
nn.Linear(2048, 32)) #101
self._features = nn.Sequential(
self.group1,
self.group2,
self.group3,
self.group4,
self.group5
)
self._classifier = nn.Sequential(
self.fc1,
self.fc2
)
model_DeepCNN_MUI.py 文件源码
项目：cnn-lstm-bilstm-deepcnn-clstm-in-pytorch
作者: bamtercelboo
项目源码
文件源码
阅读 24
收藏 0
点赞 0
评论 0
def __init__(self, args):
super(DEEP_CNN_MUI, self).__init__()
self.args = args
V = args.embed_num
V_mui = args.embed_num_mui
D = args.embed_dim
C = args.class_num
Ci = 2
Co = args.kernel_num
Ks = args.kernel_sizes
if args.max_norm is not None:
print("max_norm = {} ".format(args.max_norm))
self.embed_no_static = nn.Embedding(V, D, max_norm=args.max_norm, scale_grad_by_freq=True)
self.embed_static = nn.Embedding(V_mui, D, max_norm=args.max_norm, scale_grad_by_freq=True)
else:
print("max_norm = {} ".format(args.max_norm))
self.embed_no_static = nn.Embedding(V, D, scale_grad_by_freq=True)
self.embed_static = nn.Embedding(V_mui, D, scale_grad_by_freq=True)
if args.word_Embedding:
pretrained_weight = np.array(args.pretrained_weight)
self.embed_no_static.weight.data.copy_(torch.from_numpy(pretrained_weight))
pretrained_weight_static = np.array(args.pretrained_weight_static)
self.embed_static.weight.data.copy_(torch.from_numpy(pretrained_weight_static))
# whether to fixed the word embedding
self.embed_no_static.weight.requires_grad = True
# cons layer
self.convs1 = [nn.Conv2d(Ci, D, (K, D), stride=1, padding=(K//2, 0), bias=True) for K in Ks]
self.convs2 = [nn.Conv2d(1, Co, (K, D), stride=1, padding=(K//2, 0), bias=True) for K in Ks]
print(self.convs1)
print(self.convs2)
if args.init_weight:
print("Initing W .......")
for (conv1, conv2) in zip(self.convs1, self.convs2):
init.xavier_normal(conv1.weight.data, gain=np.sqrt(args.init_weight_value))
init.uniform(conv1.bias, 0, 0)
init.xavier_normal(conv2.weight.data, gain=np.sqrt(args.init_weight_value))
init.uniform(conv2.bias, 0, 0)
# dropout
self.dropout = nn.Dropout(args.dropout)
# linear
in_fea = len(Ks) * Co
self.fc1 = nn.Linear(in_features=in_fea, out_features=in_fea // 2, bias=True)
self.fc2 = nn.Linear(in_features=in_fea // 2, out_features=C, bias=True)
model_DeepCNN.py 文件源码
项目：cnn-lstm-bilstm-deepcnn-clstm-in-pytorch
作者: bamtercelboo
项目源码
文件源码
阅读 24
收藏 0
点赞 0
评论 0
def __init__(self, args):
super(DEEP_CNN, self).__init__()
self.args = args
V = args.embed_num
D = args.embed_dim
C = args.class_num
Ci = 1
Co = args.kernel_num
Ks = args.kernel_sizes
if args.max_norm is not None:
print("max_norm = {} ".format(args.max_norm))
self.embed = nn.Embedding(V, D, max_norm=args.max_norm, scale_grad_by_freq=True)
# self.embed.weight.data.uniform(-0.1, 0.1)
else:
print("max_norm = {} ".format(args.max_norm))
self.embed = nn.Embedding(V, D, scale_grad_by_freq=True)
# word embedding
if args.word_Embedding:
pretrained_weight = np.array(args.pretrained_weight)
self.embed.weight.data.copy_(torch.from_numpy(pretrained_weight))
# fixed the word embedding
self.embed.weight.requires_grad = True
# cons layer
self.convs1 = [nn.Conv2d(Ci, D, (K, D), stride=1, padding=(K//2, 0), bias=True) for K in Ks]
self.convs2 = [nn.Conv2d(Ci, Co, (K, D), stride=1, padding=(K//2, 0), bias=True) for K in Ks]
print(self.convs1)
print(self.convs2)
if args.init_weight:
print("Initing W .......")
for (conv1, conv2) in zip(self.convs1, self.convs2):
init.xavier_normal(conv1.weight.data, gain=np.sqrt(args.init_weight_value))
init.uniform(conv1.bias, 0, 0)
init.xavier_normal(conv2.weight.data, gain=np.sqrt(args.init_weight_value))
init.uniform(conv2.bias, 0, 0)
# dropout
self.dropout = nn.Dropout(args.dropout)
# linear
in_fea = len(Ks) * Co
self.fc1 = nn.Linear(in_features=in_fea, out_features=in_fea // 2, bias=True)
self.fc2 = nn.Linear(in_features=in_fea // 2, out_features=C, bias=True)
def make_initializer(
linear={'type': 'uniform', 'args': {'a': -0.05, 'b': 0.05}},
linear_bias={'type': 'constant', 'args': {'val': 0.}},
rnn={'type': 'xavier_uniform', 'args': {'gain': 1.}},
rnn_bias={'type': 'constant', 'args': {'val': 0.}},
cnn_bias={'type': 'constant', 'args': {'val': 0.}},
emb={'type': 'normal', 'args': {'mean': 0, 'std': 1}},
default={'type': 'uniform', 'args': {'a': -0.05, 'b': 0.05}}):
rnns = (torch.nn.LSTM, torch.nn.GRU,
torch.nn.LSTMCell, torch.nn.GRUCell,
StackedGRU, StackedLSTM, NormalizedGRU,
NormalizedGRUCell, StackedNormalizedGRU)
convs = (torch.nn.Conv1d, torch.nn.Conv2d)
def initializer(m):
if isinstance(m, (rnns)): # RNNs
for p_name, p in m.named_parameters():
if hasattr(p, 'custom'):
continue
if is_bias(p_name):
getattr(init, rnn_bias['type'])(p, **rnn_bias['args'])
else:
getattr(init, rnn['type'])(p, **rnn['args'])
elif isinstance(m, torch.nn.Linear): # linear
for p_name, p in m.named_parameters():
if hasattr(p, 'custom'):
continue
if is_bias(p_name):
getattr(init, linear_bias['type'])(p, **linear_bias['args'])
else:
getattr(init, linear['type'])(p, **linear['args'])
elif isinstance(m, torch.nn.Embedding): # embedding
for p in m.parameters():
if hasattr(p, 'custom'):
continue
getattr(init, emb['type'])(p, **emb['args'])
elif isinstance(m, convs):
for p_name, p in m.named_parameters():
if hasattr(p, 'custom'):
continue
if is_bias(p_name):
getattr(init, cnn_bias['type'])(p, **cnn_bias['args'])
else:
# Karpathy: http://cs231n.github.io/neural-networks-2/#init
# -> scale weight vector by square root of its fan-in...
# fan_in, _ = init._calculate_fan_in_and_fan_out(p)
# init.normal(p, mean=0, std=math.sqrt(fan_in))
init.xavier_normal(p)
return initializer
