def main(argv=None):
if argv is None:
argv = sys.argv
filepath = "F:\FCD data\cluster\cluster_region_1.npy"
trajectory_cluster_region = list(np.load(filepath))
training_data = []
test_data = []
all_count = len(trajectory_cluster_region)
train_data_length = int(all_count * 0.9)
count = 0
labels = []
for trajectory in trajectory_cluster_region:
count = count + 1
clusters = literal_eval(trajectory.strip().split(';')[0])
regions = literal_eval(trajectory.strip().split(';')[1])
clusters, regions = validate_trajectory(clusters, regions)
if len(clusters) < 5 or len(regions) < 5:
continue
if count < train_data_length:
training_data.append((regions, clusters))
else:
test_data.append((regions, clusters))
labels.extend(clusters)
word_to_ix = {}
for sentence, tags in training_data:
for word in sentence:
if word not in word_to_ix:
word_to_ix[word] = len(word_to_ix)
# labels = list(np.load("F:\FCD data\cluster\destination_labels.npy"))
count = 0
tag_to_ix = {}
for label in labels:
if label not in tag_to_ix.keys():
tag_to_ix[label] = count
count = count + 1
tag_to_ix[START_TAG] = count
tag_to_ix[STOP_TAG] = count + 1
model = torch.load("prediction_model.pkl")
# Check predictions before training
with torch.no_grad():
precheck_sent = prepare_sequence(test_data[2][0], word_to_ix)
precheck_tags = torch.tensor([tag_to_ix[t] for t in test_data[2][1]],
dtype=torch.long)
y = model(precheck_sent)
print(y)
make_dot(y)
print(precheck_tags)
def run(self, train_loader, test_loader, loss_fn):
try:
from visualize import make_dot
y = self.net.forward(Variable(torch.from_numpy(test_loader.dataset[0]['image'])))
g = make_dot(y)
g.engine='dot'
g.format='pdf'
print(g.render(filename=os.path.join(self.log_dir, 'net.gv')))
except:
logger.warn('failed to draw net.')
logger.check_eq(self.done, False, 'Done already!')
if self.cuda:
self.net.cuda()
logger.info('Network Architecture:')
print(str(self.net))
sys.stdout.flush()
logger.info('{} Hyperparameters:'.format(self.solver.__class__.__name__))
print(str(self.solver.defaults))
sys.stdout.flush()
logger.info('Initial test with random initialized parameters:')
self.test(epoch=0, loader=test_loader, loss_fn=loss_fn)
for epoch in range(1, self.total_epochs+1):
self.train(epoch=epoch, loader=train_loader, loss_fn=loss_fn)
self.test(epoch=epoch, loader=test_loader, loss_fn=loss_fn)
self.invoke_epoch_callback()
self.save_stats()
self.done=True
def inspect(self):
print(dir(self.dqn.conv1))
for param in list(self.dqn.parameters()):
print(param.size())
print("conv2", self.dqn.conv2.kernel_size)
print("conv3", self.dqn.conv3.kernel_size)
print("lin1", self.dqn.affine1.in_features,
self.dqn.affine1.out_features)
print("lin2", self.dqn.affine2.in_features,
self.dqn.affine2.out_features)
weights = self.dqn.affine1.weight
print(self.dqn.affine1.weight)
print((self.dqn.affine1.weight[:, 1024:]))
import visualize
inputs = torch.randn(1, 4, 64, 64)
inputs2 = additional_states = torch.zeros(4, 12)
print("state", self.dqn.state_dict)
y = self.dqn(Variable(inputs), Variable(inputs2))
g = visualize.make_dot(y, self.dqn.state_dict)
g.view()
def train_tree(self):
torch.set_default_tensor_type('torch.cuda.FloatTensor')
self.tree = dt.decision_tree().cuda()
print(self.tree)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(self.tree.parameters(), lr=0.001, momentum=0.9)
for epoch in range(
n.tree_trainer_epoch): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(pre.trainloader, 0):
inputs, labels = data
inputs, labels = Variable(inputs.cuda()), Variable(
labels.cuda())
optimizer.zero_grad()
# forward + backward + optimize
outputs = self.tree(inputs)
g = v.make_dot(outputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.data[0]
# update leaf loss statistics
self._update_leaf_loss(
loss.data[0], self.tree.exit_node
) # must be called after backwards for accurate exit node
if i % 2000 == 1999: # print every 200 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
# after every epoch, grow the tree
if self.tree.size * 3 == epoch:
self._grow_tree()
print('Finished Training')
g.view()
dtype=dtype,
ltype=ltype,
sampling_rate=sampling_rate)
# In[4]:
from visualize import make_dot
from torch.autograd import Variable
input = Variable(torch.rand(1, 1, 256))
output = model(input)
params = dict(model.named_parameters())
#output.backward()
print(output)
make_dot(output, params)
# In[5]:
print("output length: ", model.output_length)
data_loader.start_new_epoch()
start_data = data_loader.get_wavenet_minibatch([model.receptive_field],
model.receptive_field,
model.output_length)[0]
start_data = start_data.squeeze()
plt.ion()
plt.plot(start_data[-200:].numpy())
plt.ioff()
self.bn1 = nn.BatchNorm2d(12)
self.conv2 = nn.Conv2d(12, 24, 3, 2)
self.bn2 = nn.BatchNorm2d(24)
self.conv3 = nn.Conv2d(24, 48, 3, 2)
self.bn3 = nn.BatchNorm2d(48)
self.fc1 = nn.Linear(48 * 5 * 5, 1200)
self.fc2 = nn.Linear(1200, 128)
self.fc3 = nn.Linear(128, 2)
def forward(self, x):
x = F.relu(self.bn1(self.conv1(x)))
#print "bn1 shape",x.shape
x = F.relu(self.bn2(self.conv2(x)))
x = F.relu(self.bn3(self.conv3(x)))
x = x.view(-1, 48 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
if __name__ == '__main__':
import torch
from torch.autograd import Variable
from visualize import make_dot
x = Variable(torch.randn(1, 3, 48, 48))
model = simpleconv3()
y = model(x)
g = make_dot(y)
g.view()
feat_1 = self.block1(feat)
feat_2 = self.block2(feat_1)
fine_1 = F.relu(self.fine_bn1(self.fine_conv1(feat)))
fine_2 = F.relu(self.fine_bn2(self.fine_conv2(fine_1)))
fine_3 = F.relu(self.fine_bn3(self.fine_conv3(fine_2)))
out = feat_2 + fine_3
out = F.relu(self.combine_bn1(self.combine_conv1(out)))
out = self.combine_conv2(out)
return out
class networkNormal(nn.Module):
def __init__(self, inplane_normal):
super(networkNormal, self).__init__()
self.normalNetwork = basicNetwork(inplane_normal, 3)
def forward(self, in_normal):
normal = self.normalNetwork(in_normal)
return normal
if __name__ == '__main__':
net = HourglassNet()
x = Variable(torch.Tensor(1, 3, 224, 224))
albedo, norm, lighting, shading = net(x)
g = make_dot(shading)
g.render('HourglassNet')
def ConvertModel_caffe(pytorch_net,
InputShape,
softmax=False,
use_cuda=False,
save_graph=False):
""" Pytorch to Caffe, only support single tensor input """
import os
#import caffe_pb2 as pb2
from caffe.proto import caffe_pb2 as pb2
from ConvertLayer_caffe import convert_caffe
""" Need forward once """
global inputs
n, c, h, w = InputShape
if use_cuda:
print('Convert in cuda...')
if torch.cuda.is_available():
torch.set_default_tensor_type('torch.cuda.FloatTensor')
pytorch_net = pytorch_net.cuda()
inputs = Variable(torch.zeros(n, c, h, w).cuda(), requires_grad=True)
else:
inputs = Variable(torch.zeros(n, c, h, w), requires_grad=True)
pytorch_net.eval()
outputs = pytorch_net(inputs, phase='eval') #phase='eval'
print('model outputs:')
if isinstance(outputs, tuple) or isinstance(outputs, list):
#print(outputs[0].shape) #(1, 10830 4)
print(outputs[0][-1]) #last loc
else:
print(outputs)
if save_graph:
from visualize import make_dot
model_name = str(pytorch_net.__class__.__name__) + '_caffe'
fp = open("{}.dot".format(model_name), "w")
dot = make_dot(outputs)
print >> fp, dot
fp.close()
if softmax:
import torch.nn as nn
regularize = nn.Softmax()
outputs = regularize(outputs)
""" Travel computational graph in backward order """
""" Need to count number of tops(indegree) of all nodes first """
global visited, tops_dict, layer_type_count, dst
global slice_point, multi_tops, axis_dict
visited = set()
tops_dict = dict()
layer_type_count = dict()
slice_point = dict()
multi_tops = dict()
axis_dict = dict()
dst = 'caffe'
for out in outputs:
FindMultiTops(out.grad_fn)
""" Travel computational graph in backward order """
global caffe_net
global convert, link
convert = convert_caffe
link = link_caffe
caffe_net = []
visited = set()
tops_dict = dict()
layer_type_count = dict()
for out in outputs:
DFS(out.grad_fn)
""" Caffe input """
text_net = pb2.NetParameter()
if os.environ.get("T2C_DEBUG"):
text_net.debug_info = True
""" Caffe layer parameters """
binary_weights = pb2.NetParameter()
binary_weights.CopyFrom(text_net)
for layer in caffe_net:
binary_weights.layer.extend([layer])
layer_proto = pb2.LayerParameter()
layer_proto.CopyFrom(layer)
del layer_proto.blobs[:]
text_net.layer.extend([layer_proto])
return text_net, binary_weights
net = GoogLeNet()
#===================================
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(net.parameters(), lr=1e-2)
has_output = False
for epoch in range(5):
for i, (images, labels) in enumerate(train_loader):
images = Variable(images)
labels = Variable(labels)
net.zero_grad()
output = net(images)
if has_output == False:
visualize.make_dot(output).render("graph")
has_output = True
loss = criterion(output, labels)
loss.backward()
optimizer.step()
print("epoch:%d, batch:%d, loss:%.4f" % (epoch, i, loss.data[0]))
total = 0.0
correct = 0.0
for images, labels in test_loader:
images = Variable(images)
output = net(images)
val, index = torch.max(output, 1)
total += images.size(0)
correct += (index.data == labels).sum()
if model_name == 'resnet50':
m = torchvision.models.resnet50(pretrained=True)
elif model_name == 'vgg16':
m = torchvision.models.vgg16()
m.classifier.add_module('softmax', torch.nn.Softmax())
elif model_name == 'resnet26d':
m = timm.create_model('resnet26d', pretrained=True) #.cuda()
m.eval(
) # very important here, otherwise batchnorm running_mean, running_var will be incorrect
input_var = Variable(torch.rand(1, 3, 224, 224))
print(m)
output_var = m(input_var)
fp = open("out.dot", "w")
dot = make_dot(output_var)
#print >> fp, dot
dot.render('test-output/round-table.gv', view=False) #True
fp.close()
#exit(0)
if model_name == 'resnet50':
pytorch2caffe(input_var, output_var, 'resnet50-pytorch2caffe.prototxt',
'resnet50-pytorch2caffe.caffemodel')
elif model_name == 'vgg16':
pytorch2caffe(input_var, output_var, 'vgg16-pytorch2caffe.prototxt',
'vgg16-pytorch2caffe.caffemodel')
elif model_name == 'resnet26d':
pytorch2caffe(input_var, output_var,
'resnet26d-pytorch2caffe.prototxt',
'resnet26d-pytorch2caffe.caffemodel')
print(epoch)
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# get the inputs
inputs, labels = data
# wrap them in Variable
inputs, labels = Variable(inputs.cuda()), Variable(labels.cuda())
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
g = v.make_dot(outputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.data[0]
if i % 2000 == 1999: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
g.view()
print('Finished Training')
dataiter = iter(testloader)
images, labels = dataiter.next()
# tr_scans = np.load("../tr_sacns.npy")
# tr_wcs = np.load("../tr_wcs.npy")
# tr_was = np.load("../tr_was.npy")
Xva = np.load("./Xva.npy")
# # Xte = np.load( "../Xte.npy" )
va_wcs = np.load("./va_wcs.npy")
# # te_wcs=np.load("../te_wcs.npy")
va_was = np.load("./va_was.npy")
# # te_was=np.load("../te_was.npy")
va_scans = np.load("./va_scans.npy")
#
EPOCH = 1
p1, p2 = 1, 1
for epoch in range(EPOCH):
for step, (x, yOffs, yConf) in enumerate(train_loader):
(outConf, outOffs) = net(x)
g,p=make_dot(outConf),make_dot(outOffs)
# g.view()
p.view()
yConfl = yConf.type(torch.LongTensor)
# if step == 0:
# p1 = 1 / loss_softmax(outConf, yConfl)
# p2 = 1 / loss_offset(outOffs, yOffs)
a,b=loss_softmax(outConf, yConfl),loss_offset(outOffs, yOffs)
loss = a+ b*25
optimizer.zero_grad()
loss.backward()
optimizer.step()
if step!=0:
break
# print("EPOCH : ",epoch," loss_softmax : ",a," loss_offset : ",b*25," loss_tatal : ", loss)
# optimizer.step() # apply gradients
for epoch in range(num_epochs):
batch_size_start = time.time()
running_loss = 0.0
for i, (inputs) in enumerate(train_loader):
optimizer = torch.optim.SGD(alexnet_model.classifier.parameters(),
lr=0.0001, momentum=0.9, weight_decay=0.0005,
)
torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=1e-7) #每个epoch更新一次lr
inputs = Variable(inputs)
labels = Variable(labels)
optimizer.zero_grad()
outputs = alexnet_model(inputs)
criterion = nn.CrossEntropyLoss()
loss = criterion(outputs, labels) # 交叉熵
loss.backward()
optimizer.step() # 更新权重
running_loss += loss.data[0]
print('Epoch [%d/%d], Loss: %.4f,need time %.4f'
% (epoch + 1, num_epochs, running_loss / (4000 / batch_size), time.time() - batch_size_start))
#可视化
g = make_dot(alexnet_model)
g.view()
# 保存模型和特征
saveModelName = os.path.join(codeDirRoot, "model", "alexnet_model.pkl" + "_" + str(num_epochs))
torch.save(alexnet_model.state_dict(), saveModelName)
def visualize_model(self, X_test):
out = self.forward(X_test)
make_dot(out)
# -*- coding:utf-8 -*- import torch from torch.autograd import Variable from models.network import PyramidHourglassNet from visualize import make_dot x = Variable(torch.randn(6, 3, 256, 256)) model = PyramidHourglassNet(nFeats=256, nModules=2, numOutput=16, nStack=2) y = model(x) # 测流动方向，如果batch按照(6,3,256,256)放置，就用y[index]，因为y是个list,没有grad_fn # 否则直接y就可以 g = make_dot(y[0]) g = make_dot(y) g.view()
