def different_classification(csv_file,
train_dict,
need_classes,
batch_size=30,
plot=True,
verbose=0):
'''
train_dict = {0: for test, 1 for training}
'''
# Load data
embeddings, labels = loadData(csv_file, dtypes)
# Prepare data
X_train, X_test, y_train, y_test = splitGroups(embeddings, labels,
need_classes, classes,
train_dict)
y_train = to_categorical(y_train)
y_test = to_categorical(y_test, 3)
output_size = len(np.unique(list(need_classes.values())))
classifier(X_train,
X_test,
y_train,
y_test,
output_size,
'test',
batch_size=batch_size,
plot=plot,
verbose=verbose)
def simple_classification(csv_file,
need_classes,
title,
batch_size=30,
plot=True,
verbose=0):
# Load data
embeddings, labels = loadData(csv_file, dtypes)
# Prepare data
labels = changeGroups(labels, classes, need_classes)
labels = to_categorical(labels)
output_size = len(np.unique(list(need_classes.values())))
# Split data
X_train, X_test, y_train, y_test = train_test_split(embeddings,
labels,
test_size=0.33)
classifier(X_train,
X_test,
y_train,
y_test,
output_size,
title,
batch_size=batch_size,
plot=plot,
verbose=verbose)
def split_classes(csv_file):
embeddings, labels = loadData(csv_file, dtypes)
data_dict = {}
for cl, id in classes.items():
embeddings_cl, labels_cl = onlyGroup(embeddings, labels, [id], classes)
X_train, X_test, y_train, y_test = train_test_split(embeddings_cl,
labels_cl,
test_size=250)
data_dict[cl] = {'train': [X_train, y_train], 'test': [X_test, y_test]}
return data_dict
def main():
args = getArguments()
SPLIT = 100
#
# prepare DATA
#
print "Load Data"
X, char_dict = loadData()
X = X[:100]
print "load existing model: ", args.model
autoencoder = load_model(args.model)
y_hat = autoencoder.predict(X)
for idx in range(X.shape[0]):
x1 = decode(np.argmax(X[idx], axis=1), char_dict)
x2 = decode(np.argmax(y_hat[idx], axis=1), char_dict)
print "".join(x1), "".join(x2)
raw_input()
def main():
args = getArguments()
SPLIT = 100
#
# prepare DATA
#
print "Load Data"
X, char_dict = loadData()
X = X[:100]
print "load existing model: ", args.model
autoencoder = load_model(args.model)
y_hat = autoencoder.predict(X)
for idx in range(X.shape[0]):
x1 = decode(np.argmax(X[idx], axis=1),char_dict)
x2 = decode(np.argmax(y_hat[idx],axis=1),char_dict)
print "".join(x1), "".join(x2)
raw_input()
os.path.join(args.save_dir, "collect_score"))
if __name__ == '__main__':
args = parse_args()
utils.mkdir(args.save_dir)
# cls and sord
print("Loading model weight......")
model = MobileNetV2(num_classes=args.num_classes)
saved_state_dict = torch.load(args.snapshot)
model.load_state_dict(saved_state_dict)
model.cuda(0)
model.eval() # Change model to 'eval' mode (BN uses moving mean/var).
softmax = nn.Softmax(dim=1).cuda(0)
# test dataLoader
test_loader = loadData(args.test_data, args.input_size, args.batch_size,
args.num_classes, False)
# testing
print('Ready to test network......')
if args.collect_score:
utils.mkdir(os.path.join(args.save_dir, "collect_score"))
test(model, test_loader, softmax, args)
def train():
"""
:return:
"""
# create model
model = MobileNetV2(args.num_classes, width_mult=args.width_mult)
# loading pre trained weight
logger.logger.info("Loading PreTrained Weight".center(100, '='))
utils.load_filtered_stat_dict(
model, model_zoo.load_url(model_urls["mobilenet_v2"]))
# loading data
logger.logger.info("Loading data".center(100, '='))
train_data_loader, valid_data_loader = loadData(args.train_data,
args.input_size,
args.batch_size,
args.num_classes)
print()
# initialize loss function
cls_criterion = nn.BCEWithLogitsLoss().cuda(0)
reg_criterion = nn.MSELoss().cuda(0)
softmax = nn.Softmax(dim=1).cuda(0)
model.cuda(0)
# training
logger.logger.info("Training".center(100, '='))
# initialize learning rate and step
lr = args.lr
step = 0
for epoch in range(args.epochs + 1):
print("Epoch:", epoch)
if epoch > args.unfreeze:
optimizer = torch.optim.Adam(
[{
"params": get_non_ignored_params(model),
"lr": lr
}, {
"params": get_cls_fc_params(model),
"lr": lr
}],
lr=args.lr)
else:
optimizer = torch.optim.Adam(
[{
"params": get_non_ignored_params(model),
"lr": 0
}, {
"params": get_cls_fc_params(model),
"lr": lr * 5
}],
lr=args.lr)
lr = lr * args.lr_decay
min_degree_error = 180.
for i, (images, classify_label, vector_label,
name) in enumerate(train_data_loader):
step += 1
images = images.cuda(0)
classify_label = classify_label.cuda(0)
vector_label = vector_label.cuda(0)
# inference
x_cls_pred, y_cls_pred, z_cls_pred = model(images)
logits = [x_cls_pred, y_cls_pred, z_cls_pred]
loss, degree_error = utils.computeLoss(classify_label,
vector_label, logits,
softmax, cls_criterion,
reg_criterion, args)
#print(loss)
# backward
grad = [torch.tensor(1.0).cuda(0) for _ in range(3)]
optimizer.zero_grad()
torch.autograd.backward(loss, grad)
optimizer.step()
# save training log and weight
if (i + 1) % 10 == 0:
msg = "Epoch: %d/%d | Iter: %d/%d | x_loss: %.6f | y_loss: %.6f | z_loss: %.6f | degree_error:%.3f" % (
epoch, args.epochs, i + 1, len(train_data_loader.dataset)
// args.batch_size, loss[0].item(), loss[1].item(),
loss[2].item(), degree_error.item())
logger.logger.info(msg)
valid_degree_error = valid(model, valid_data_loader, softmax)
# writer summary
writer.add_scalar("train degrees error", degree_error, step)
writer.add_scalar("valid degrees error", valid_degree_error,
step)
# saving snapshot
if valid_degree_error < min_degree_error:
min_degree_error = valid_degree_error
logger.logger.info(
"A better validation degrees error {}".format(
valid_degree_error))
torch.save(
model.state_dict(),
os.path.join(
snapshot_dir,
output_string + '_epoch_' + str(epoch) + '.pkl'))
from numpy import empty, inf, zeros, array, abs, count_nonzero
from matplotlib.pyplot import ion, draw, plot, savefig
from cv2 import imwrite, waitKey
from LogisticRegression import LogisticRegression as LogReg
from theano import function, pp, config as cfg
from time import sleep
# cfg.openmp = True
import theano.tensor as T
from dataset import loadData, OneToMany
from visual import visualize
Tr, Ts, _ = loadData('mnist.pkl.gz', True)
m_sample = Tr[0].shape[0]
m_test_sample = Ts[1].shape[0]
x, y = T.dmatrices('x', 'y')
L = LogReg(x, 784, 10)
lam = 0.04
p = L.predict()
l = L.cost(y) + L.regularizer(lam)
gw = T.grad(l, wrt=L.W)
gb = T.grad(l, wrt=L.B)
alpha = 0.05
W_shape = L.weightShapes()[0]
B_shape = L.weightShapes()[1]
VW = zeros(W_shape)
VB = zeros(B_shape)
train = function([x, y], [l, gw, gb])
save best model parameters
"""
import torch
import zoo
import numpy as np
from dataset import loadData
from crossvalidation import crossval_proc
minibatchsize = 64
NcrossVal = 5
# trainloader, validationloader, testloader
dataloaders = loadData(minibatchsize)
nn = zoo.CNN_class
model_param = {
#"nClass": 10,
"hiddenCells": 25
}
train_param = {
# Adam optimizer
# "optimizer": torch.optim.Adam,
# "opt_param": {"lr": 0.001},
# Stochastic Gradient Descent Optimizer
"optimizer": torch.optim.SGD,
from matplotlib.pyplot import ion, draw, plot, savefig
from ConvNet import LeConvNet
from theano import function, pp, tensor as T
from dataset import loadData, OneToMany
from numpy import zeros, abs, array, count_nonzero
Tr, Ts, _ = loadData('mnist.pkl.gz', True)
m_sample = 10000
m_test_sample = 500
X = Tr[0].reshape((50000,1,28,28))[:m_sample,:,:,:];Y = Tr[1][:m_sample]
Xt = Ts[0].reshape((10000,1,28,28))[:m_test_sample,:,:,:];Yt = Ts[1][:m_test_sample]
del Tr; del Ts
# Hyper-parameters
alpha = 0.5
zeta = 0.99
lam = 0.01
x = T.tensor4('x')
y = T.dmatrix('y')
LCV = LeConvNet(x)
cost = LCV.cost(y) + LCV.regularization() * lam
params = LCV.params()
grads = [ T.grad(cost,wrt=p) for p in params ]
V = [zeros(g) for g in LCV.paramshapes()]
train = function( [x, y], [cost] + grads )
p = LCV.predict()
predict = function ([x],p)
print 'Functions compiled'
def train(net, bins, alpha, beta, batch_size):
"""
params:
bins: number of bins for classification
alpha: regression loss weight
beta: ortho loss weight
"""
# create model
if net == "resnet50":
model = ResNet(torchvision.models.resnet50(pretrained=True),
num_classes=bins)
lr = args.lr_resnet
else:
model = MobileNetV2(bins)
lr = args.lr_mobilenet
# loading data
logger.logger.info("Loading data".center(100, '='))
train_data_loader = loadData(args.train_data, args.input_size, batch_size,
bins)
valid_data_loader = loadData(args.valid_data, args.input_size, batch_size,
bins, False)
# initialize cls loss function
if args.cls_loss == "KLDiv":
cls_criterion = nn.KLDivLoss(reduction='batchmean').cuda(0)
elif args.cls_loss == "BCE":
cls_criterion = nn.BCELoss().cuda(0)
# initialize reg loss function
reg_criterion = nn.MSELoss().cuda(0)
softmax = nn.Softmax(dim=1).cuda(0)
model.cuda(0)
# training log
logger.logger.info("Training".center(100, '='))
# initialize learning rate and step
lr = lr
step = 0
# validation error
min_avg_error = 1000.
# start training
for epoch in range(args.epochs):
print("Epoch:", epoch)
# learning rate initialization
if net == 'resnet50':
if epoch >= args.unfreeze:
optimizer = torch.optim.Adam(
[{
"params": get_non_ignored_params(model, net),
"lr": lr
}, {
"params": get_cls_fc_params(model),
"lr": lr * 10
}],
lr=args.lr_resnet)
else:
optimizer = torch.optim.Adam(
[{
"params": get_non_ignored_params(model, net),
"lr": lr
}, {
"params": get_cls_fc_params(model),
"lr": lr * 10
}],
lr=args.lr_resnet)
else:
if epoch >= args.unfreeze:
optimizer = torch.optim.Adam(
[{
"params": get_non_ignored_params(model, net),
"lr": lr
}, {
"params": get_cls_fc_params(model),
"lr": lr
}],
lr=args.lr_mobilenet)
else:
optimizer = torch.optim.Adam(
[{
"params": get_non_ignored_params(model, net),
"lr": lr * 10
}, {
"params": get_cls_fc_params(model),
"lr": lr * 10
}],
lr=args.lr_mobilenet)
# reduce lr by lr_decay factor for each epoch
lr = lr * args.lr_decay
print("------------")
for i, (images, cls_v1, cls_v2, cls_v3, reg_v1, reg_v2, reg_v3,
name) in enumerate(train_data_loader):
step += 1
images = images.cuda(0)
# get classified labels
cls_v1 = cls_v1.cuda(0)
cls_v2 = cls_v2.cuda(0)
cls_v3 = cls_v3.cuda(0)
# get continuous labels
reg_v1 = reg_v1.cuda(0)
reg_v2 = reg_v2.cuda(0)
reg_v3 = reg_v3.cuda(0)
# inference
x_pred_v1, y_pred_v1, z_pred_v1, x_pred_v2, y_pred_v2, z_pred_v2, x_pred_v3, y_pred_v3, z_pred_v3 = model(
images)
logits = [
x_pred_v1, y_pred_v1, z_pred_v1, x_pred_v2, y_pred_v2,
z_pred_v2, x_pred_v3, y_pred_v3, z_pred_v3
]
loss, degree_error_v1, degree_error_v2, degree_error_v3 = utils.computeLoss(
cls_v1, cls_v2, cls_v3, reg_v1, reg_v2, reg_v3, logits,
softmax, cls_criterion, reg_criterion, [
bins, alpha, beta, args.cls_loss, args.reg_loss,
args.ortho_loss
])
# backward
grad = [torch.tensor(1.0).cuda(0) for _ in range(3)]
optimizer.zero_grad()
torch.autograd.backward(loss, grad)
optimizer.step()
# save training log and weight
if (i + 1) % 100 == 0:
msg = "Epoch: %d/%d | Iter: %d/%d | x_loss: %.6f | y_loss: %.6f | z_loss: %.6f | degree_error_f:%.3f | degree_error_r:%.3f | degree_error_u:%.3f" % (
epoch, args.epochs, i + 1, len(train_data_loader.dataset)
// batch_size, loss[0].item(), loss[1].item(),
loss[2].item(), degree_error_v1.item(),
degree_error_v2.item(), degree_error_v3.item())
logger.logger.info(msg)
# Test on validation dataset
error_v1, error_v2, error_v3 = valid(model, valid_data_loader, softmax,
bins)
print("Epoch:", epoch)
print("Validation Error:", error_v1.item(), error_v2.item(),
error_v3.item())
logger.logger.info("Validation Error(l,d,f)_{},{},{}".format(
error_v1.item(), error_v2.item(), error_v3.item()))
# save model if achieve better validation performance
if error_v1.item() + error_v2.item() + error_v3.item() < min_avg_error:
min_avg_error = error_v1.item() + error_v2.item() + error_v3.item()
print("Training Info:")
print("Model:", net, " ", "Number of bins:", bins, " ", "Alpha:",
alpha, " ", "Beta:", beta)
print("Saving Model......")
torch.save(
model.state_dict(),
os.path.join(snapshot_dir, output_string + '_Best_' + '.pkl'))
print("Saved")
# 1. 데이터 준비하기
# 코드 사전 정의
code2idx = {'bend': 0, 'unfold': 1}
idx2code = {
0: 'zero',
1: 'one',
2: 'two',
3: 'three',
4: 'four',
5: 'five',
6: 'error'
}
# 2. 데이터셋 생성하기
(x_train, t_train), (x_test, t_test) = loadData()
max_idx_value = 6
one_hot_vec_size = t_train.shape[1]
print("one hot encoding vector size is ", one_hot_vec_size)
# 3. 모델 구성하기
model = Sequential()
model.add(Dense(128, input_dim=5, activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(Dense(one_hot_vec_size, activation='softmax'))
# 4. 모델 학습과정 설정하기
print("Testing Accuracy: {}".format(test_acc/len(test_loader.dataset)))
if __name__ == "__main__":
args = parse_args()
img_dir = args.img_dir
xml_dir = args.xml_dir
input_size = args.input_size
batch_size = args.batch_size
num_classes = args.num_classes
snapshot = args.snapshot
#model = ResNet(torchvision.models.resnet50(pretrained=False), num_classes)
print("Loading weight......")
#saved_state_dict = torch.load(snapshot)
#model.load_state_dict(saved_state_dict)
model = torch.load(snapshot)
model.cuda(0)
model.eval()
test_loader = loadData(img_dir, xml_dir, input_size, batch_size, False)
print("Start testing...")
# run train function
test(img_dir, xml_dir, input_size, batch_size, model, test_loader)
def train(img_dir, xml_dir, epochs, input_size, batch_size, num_classes):
"""
params:
bins: number of bins for classification
alpha: regression loss weight
beta: ortho loss weight
"""
# create model
model = ResNet(torchvision.models.resnet50(pretrained=True),
num_classes=num_classes)
cls_criterion = nn.CrossEntropyLoss().cuda(1)
softmax = nn.Softmax(dim=1).cuda(1)
model.cuda(1)
# initialize learning rate and step
lr = 0.001
step = 0
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
#load data
train_data_loader = loadData(img_dir, xml_dir, input_size, batch_size,
True)
test_loader = loadData('../yolov3/data/test_imgs',
'../yolov3/data/test_anns', 224, 8, False)
#variables
history = []
best_acc = 0.0
best_epoch = 0
# start training
for epoch in range(epochs):
print("Epoch:", epoch)
print("------------")
# reduce lr by lr_decay factor for each epoch
if epoch % 10 == 0:
lr = lr * 0.9
train_loss = 0.0
train_acc = 0
val_acc = 0
model.train()
for i, (images, labels) in enumerate(train_data_loader):
if i % 10 == 0:
print("batch: {}/{}".format(
i,
len(train_data_loader.dataset) // batch_size))
images = images.cuda(1)
labels = labels.cuda(1)
# backward
optimizer.zero_grad()
outputs = model(images)
loss = cls_criterion(outputs, labels)
loss.backward()
optimizer.step()
train_loss += loss.item()
ret, predictions = torch.max(outputs.data, 1)
correct_counts = predictions.eq(labels.data.view_as(predictions))
acc = torch.mean(correct_counts.type(torch.FloatTensor))
train_acc += acc.item() * images.size(0)
print("epoch: {:03d}, Training loss: {:.4f}, Accuracy: {:.4f}%".format(
epoch + 1, train_loss, train_acc / 3096 * 100))
#if (epoch+1) % 3 == 0:
# torch.save(model, 'models/'+'model_'+str(epoch+1)+'.pt')
print("Start testing...")
with torch.no_grad():
model.eval()
for j, (images, labels) in enumerate(test_loader):
images = images.cuda(1)
labels = labels.cuda(1)
outputs = model(images)
ret, preds = torch.max(outputs.data, 1)
cnt = preds.eq(labels.data.view_as(preds))
acc = torch.mean(cnt.type(torch.FloatTensor))
val_acc += acc.item() * images.size(0)
if val_acc > best_acc:
print("correct testing samples:", val_acc)
best_acc = val_acc
torch.save(model,
'models/' + 'model_' + str(epoch + 1) + '.pt')
if (btlnkFeatures):
(xTrain, yTrain, fnTrain, xTest, yTest, fnTest, xValid, yValid, fnValid,
input_dim, fileNames) = dataset.loadBottleneckData(
logger,
normalize=True,
sharedVariable=False,
reshapeToChannels=True,
n_context_frames=num_context_frames)
else:
(xTrain, yTrain, fnTrain, xTest, yTest, fnTest, xValid, yValid, fnValid,
input_dim,
fileNames) = dataset.loadData(logger,
normalize=normalization,
sharedVariable=False,
reshapeToChannels=True,
n_context_frames=num_context_frames)
if logger.isFirstEpoch():
logger.printInfo('model :\t{}'.format(model))
logger.printInfo('n epochs:\t{}'.format(num_epochs))
logger.printInfo('l rate :\t{}'.format(learning_rate))
logger.printInfo('n cntx :\t{}'.format(num_context_frames))
logger.printInfo('n btlnk :\t{}'.format(n_bottleneck))
logger.printInfo('in_dim :\t{}'.format(input_dim))
from mlp import build_model
build_model([(xTrain, yTrain), (xValid, yValid), (xTest, yTest)],
model=model,
input_dim=input_dim,
def train():
"""
:return:
"""
# create model
model = vgg19_bn()
if torch.cuda.device_count() > 1:
model = nn.DataParallel(model)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
num_params = sum(p.numel() for p in net.parameters() if p.requires_grad)
print('The number of parameters of model is', num_params)
# loading pre trained weight
#logger.logger.info("Loading PreTrained Weight".center(100, '='))
#utils.load_filtered_stat_dict(model, model_zoo.load_url(model_urls["mobilenet_v2"]))
# loading data
logger.logger.info("Loading data".center(100, '='))
train_data_loader, valid_data_loader = loadData(args.train_data, args.input_size, args.batch_size, args.num_classes)
print()
# initialize loss function
cls_criterion = nn.BCEWithLogitsLoss()
reg_criterion = nn.MSELoss()
softmax = nn.Softmax(dim=1)
#model.to(device)
# training
logger.logger.info("Training".center(100, '='))
# initialize learning rate and step
lr = args.lr
step = 0
for epoch in range(args.epochs + 1):
print("Epoch:", epoch)
if epoch > args.unfreeze:
optimizer = torch.optim.Adam([{"params": get_non_ignored_params(model), "lr": lr},
{"params": get_cls_fc_params(model), "lr": lr}], lr=args.lr)
else:
optimizer = torch.optim.Adam([{"params": get_non_ignored_params(model), "lr": lr},
{"params": get_cls_fc_params(model), "lr": lr * 10}], lr=args.lr)
lr = lr * args.lr_decay
min_degree_error = 180.
for i, (images, cls_label_f, cls_label_r, cls_label_u, vector_label_f, vector_label_r, vector_label_u, name) in enumerate(train_data_loader):
step += 1
images = images.to(device)
#classify_label = classify_label.cuda(0)
#vector_label = vector_label.cuda(0)
cls_label_f = cls_label_f.to(device)
cls_label_r = cls_label_r.to(device)
cls_label_u = cls_label_u.to(device)
vector_label_f = vector_label_f.to(device)
vector_label_r = vector_label_r.to(device)
vector_label_u = vector_label_u.to(device)
# inference
x_cls_pred_f, y_cls_pred_f, z_cls_pred_f,x_cls_pred_r, y_cls_pred_r, z_cls_pred_r,x_cls_pred_u, y_cls_pred_u, z_cls_pred_u = model(images)
logits = [x_cls_pred_f, y_cls_pred_f, z_cls_pred_f,x_cls_pred_r, y_cls_pred_r, z_cls_pred_r,x_cls_pred_u, y_cls_pred_u, z_cls_pred_u]
loss, degree_error_f, degree_error_r, degree_error_u = utils.computeLoss(cls_label_f, cls_label_r, cls_label_u,
vector_label_f, vector_label_r, vector_label_u,
logits, softmax, cls_criterion, reg_criterion, args)
#print(loss)
# backward
grad = [torch.tensor(1.0).to(device) for _ in range(12)]
optimizer.zero_grad()
torch.autograd.backward(loss, grad)
optimizer.step()
# save training log and weight
if (i + 1) % 50 == 0:
msg = "Epoch: %d/%d | Iter: %d/%d | x_loss: %.6f | y_loss: %.6f | z_loss: %.6f | degree_error_f:%.3f | degree_error_r:%.3f | degree_error_u:%.3f" % (
epoch, args.epochs, i + 1, len(train_data_loader.dataset) // args.batch_size, loss[0].item()+loss[3].item()+loss[6].item(), loss[1].item()+loss[4].item()+loss[7].item(),
loss[2].item()+loss[5].item()+loss[8].item(), degree_error_f.item(), degree_error_r.item(), degree_error_u.item())
logger.logger.info(msg)
valid_degree_error_f, valid_degree_error_r, valid_degree_error_u = valid(model, valid_data_loader, softmax)
# writer summary
writer.add_scalar("train degrees error", degree_error_f, step)
writer.add_scalar("valid degrees error", valid_degree_error_f, step)
# saving snapshot
if valid_degree_error_f + valid_degree_error_r + valid_degree_error_u < min_degree_error:
min_degree_error = valid_degree_error_f + valid_degree_error_r + valid_degree_error_u
logger.logger.info("A better validation degrees error {}".format(min_degree_error))
torch.save(model.state_dict(), os.path.join(snapshot_dir, output_string + '_epoch_' + str(epoch) + '_constrain_a=0.075' +'.pkl'))
