def main():
model = VGGNet()
model.train = True
model = Classifier(model)
model0 = copy.deepcopy(model)
model1 = copy.deepcopy(model)
model2 = copy.deepcopy(model)
model3 = copy.deepcopy(model)
model0.to_gpu(0)
model1.to_gpu(1)
model2.to_gpu(2)
model3.to_gpu(3)
ds = np.load(
"/home/kaunildhruv/fbsource/fbcode/experimental/themachinist/ml/autoencoders/preprocess_ds.npz"
)
print("Dataset loaded.")
train, test = tuple_dataset.TupleDataset(
ds["train_img"],
ds["train_lable"]), tuple_dataset.TupleDataset(ds["test_img"],
ds["test_lable"])
train_iter = iterators.SerialIterator(train, batch_size=bs, shuffle=True)
test_iter = iterators.SerialIterator(test,
batch_size=bs,
shuffle=False,
repeat=False)
optimizer = optimizers.Adam(alpha=0.001, beta1=0.9, beta2=0.999, eps=1e-08)
optimizer.setup(model)
updater = training.ParallelUpdater(train_iter,
optimizer,
devices={
'main': 0,
'first': 1,
'second': 2,
'third': 3
})
trainer = training.Trainer(updater, (epochs, 'epoch'), out='result')
#trainer.extend(Evaluator(test_iter, model))
trainer.extend(extensions.LogReport())
interval = (5, 'epoch')
iter_interval = (10000, 'iteration')
trainer.extend(extensions.snapshot_object(model,
'epoch-{.updater.epoch}.model'),
trigger=interval)
trainer.extend(extensions.snapshot_object(
model, 'iteration-{.updater.iteration}.model'),
trigger=iter_interval)
trainer.extend(extensions.snapshot(), trigger=interval)
trainer.extend(extensions.PrintReport(['epoch', 'main/loss']))
trainer.extend(extensions.ProgressBar())
trainer.run()
def __init__(self, logger, maxDicFile, **kwargs):
self.picSearResPos = kwargs['picSearResPos']
self.maxFileCount = kwargs['maxFileCount']
self.picVGGDB = kwargs['picVGGDB']
self.picSearTempPos = kwargs['picSearTempPos']
params = kwargs['esConnect']
self.es = connections.create_connection(**params)
self.esIndex = kwargs['INDEX']
self.esType = kwargs['TYPE']
self.featureDS = kwargs['featureDS']
self.imgPathDS = kwargs['imgPathDS']
self.imgNameFront = kwargs['imgNameFront']
self.picSavePos = kwargs['picSavePos']
self.maxTargetDic = maxDicFile[0]
self.remainFileCout = self.maxFileCount - maxDicFile[1]
self.model = VGGNet.CreateVGGNet()
self.picLog = logger
self.picDict={}
elif flist[i].find('doc164234') > -1:
shochigu.append(3)
elif flist[i].find('har-tip') > -1:
shochigu.append(4)
return shochigu
if __name__ == '__main__':
features = []
features2 = []
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=0)
parser.add_argument('--cluster', type=int, default=5)
args = parser.parse_args()
vgg = VGGNet()
serializers.load_hdf5('Train.model', vgg)
if args.gpu >= 0:
cuda.get_device(args.gpu)
vgg.to_gpu()
flist = glob.glob("./Images/*.jpg")
features = correct_list_features(flist, vgg, features)
ans = shochigu(flist)
#ans = cat0dog1(flist)
model = KMeans(n_clusters=args.cluster, random_state=0)
labels = model.fit_predict(features)
length = model.transform(features)
centers = model.cluster_centers_
s_len = model.transform(centers)
def run():
ConvNet = VGGNet()
ReLU = np.vectorize(FFActivation)
#Preprocessing Art and Photo
pixel_mean = [103.939, 116.779, 123.680]
art = imread('result/starryNight.jpg')
art = imresize(art, (224, 224))
art[:, :, 0] = art[:, :, 0] - pixel_mean[0]
art[:, :, 1] = art[:, :, 1] - pixel_mean[1]
art[:, :, 2] = art[:, :, 2] - pixel_mean[2]
photo = imread('result/stanford.jpeg')
photo = imresize(photo, (224, 224))
photo[:,:,0] = photo[:, :, 0] - pixel_mean[0]
photo[:,:,1] = photo[:, :, 1] - pixel_mean[1]
photo[:,:,2] = photo[:, :, 2] - pixel_mean[2]
print "load image complete"
whiteImage = np.ones((224, 224, 3)) * 255
whiteImage[:,:,0] -= pixel_mean[0]
whiteImage[:,:,1] -= pixel_mean[1]
whiteImage[:,:,2] -= pixel_mean[2]
configuration = {
"layers" : ['conv', 'conv', 'pool', 'conv', 'conv', 'pool', 'conv', 'conv', 'conv', 'conv', 'pool',
'conv', 'conv', 'conv', 'conv', 'pool', 'conv'],
"style_weights" : [1/5, 0, 0, 1/5, 0, 0, 1/5, 0, 0, 0, 0, 1/5, 0, 0, 0, 0, 1/5],
"content_weights": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
"pixel_mean" : pixel_mean
}
#initial passing of Photo through ConvNet
for i in range(13):
ConvNet.F[i] = np.load("Data/F"+str(i)+".npy")
ConvNet.A[i] = np.load("Data/A"+str(i)+".npy")
#initial passing of Photo through ConvNet
# output = photo
# for i in range(13):
# convolvedImage = ConvNet.convolution(output, ConvNet.Conv_W[i],ConvNet.bias[i])
# output = ReLU( convolvedImage )
# ConvNet.P[i] = ConvNet.unroll(output)
# np.save("Data/F"+ str(i)+".npy", ConvNet.P[i])
# if i in [1, 3, 7, 11]:
# output = ConvNet.pool(output)
# output = art
# for i in range(13):
# convolvedImage = ConvNet.convolution(output, ConvNet.Conv_W[i],ConvNet.bias[i])
# output = ReLU( convolvedImage )
# ConvNet.F[i] = ConvNet.unroll(output)
# ConvNet.A[i] = np.dot(ConvNet.F[i], ConvNet.F[i].T)
# np.save("Data/A"+ str(i)+".npy", ConvNet.A[i])
# if i in [1, 3, 7, 11]:
# output = ConvNet.pool(output)
print "initial feed forward complete"
#run optimization
ADAM(ConvNet, 500, 2, whiteImage, pixel_mean)
import chainer
import cPickle as pickle
from VGGNet import VGGNet
from chainer import cuda
from chainer import serializers
from chainer import Variable
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--model',
type=str,
default='data/VGG_ILSVRC_16_layers.caffemodel')
parser.add_argument('--prototxt',
type=str,
default='data/VGG_ILSVRC_16_layers_deploy.prototxt')
args = parser.parse_args()
vgg = VGGNet()
net = caffe.Net(args.prototxt, args.model, caffe.TEST)
for name, param in net.params.iteritems():
layer = getattr(vgg, name)
print name, param[0].data.shape, param[1].data.shape,
print layer.W.data.shape, layer.b.data.shape
layer.W = Variable(param[0].data)
layer.b = Variable(param[1].data)
setattr(vgg, name, layer)
serializers.save_hdf5('VGG.model', vgg)
from chainer import serializers
from chainer import Variable
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', type=int, default=-1)
parser.add_argument('--image', type=str, default='images/cat.jpg')
args = parser.parse_args()
mean = np.array([103.939, 116.779, 123.68])
img = cv.imread(args.image).astype(np.float32)
img -= mean
img = cv.resize(img, (224, 224)).transpose((2, 0, 1))
img = img[np.newaxis, :, :, :]
vgg = VGGNet()
serializers.load_hdf5('VGG.model', vgg)
if args.gpu >= 0:
cuda.get_device(args.gpu).user()
vgg.to_gpu()
img = cuda.cupy.asarray(img, dtype=np.float32)
pred = vgg(Variable(img), None)
if args.gpu >= 0:
pred = cuda.to_cpu(pred.data)
else:
pred = pred.data
words = open('data/synset_words.txt').readlines()
words = [(w[0], ' '.join(w[1:])) for w in [w.split() for w in words]]
# partition the data into training and testing splits using 80% of
# the data for training and the remaining 20% for testing
(trainX, testX, trainY, testY) = train_test_split(data,
labels, test_size=0.2,
random_state=42)
# construct the image generator for data augmentation
aug = ImageDataGenerator(rotation_range=25, width_shift_range=0.1,
height_shift_range=0.1, shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True, fill_mode='nearest')
#####################################################################
# initialize the model
print('==> Compiling model...')
model = VGGNet.build(width=IMAGE_DIMS[1], height=IMAGE_DIMS[0],
depth=IMAGE_DIMS[2], classes=len(lb.classes_))
opt = Adam(lr=args.lr, decay=args.lr / args.num_epochs)
model.compile(loss='categorical_crossentropy', optimizer=opt,
metrics=['accuracy'])
#####################################################################
# train the network
print('==> Training the network...')
history = model.fit_generator(
aug.flow(trainX, trainY, batch_size=args.batch_size),
validation_data=(testX, testY),
steps_per_epoch=len(trainX) // args.batch_size,
epochs=args.num_epochs, verbose=1)
#####################################################################
# save the model
from chainer import Variable
import chainer.functions as F
from VGGNet import VGGNet
from VGGNet_Input_Layer2Out import VGGNet_Input_Layer2Out
from VGGNetLayer3 import VGGNetLayer3
from VGGNetLayer4 import VGGNetLayer4
from VGGNetLayer5 import VGGNetLayer5
from VGGNetLayerFC import VGGNetLayerFC
imagefolder = "images"
resultfolder = "."
mean = np.array([103.939, 116.779, 123.68])
vggall = VGGNet()
serializers.load_hdf5('VGG.model', vggall)
# Submodel from input layer to layer 2 output
vgg2 = VGGNet_Input_Layer2Out()
vgg2.conv1_1 = vggall.conv1_1.copy()
vgg2.conv1_2 = vggall.conv1_2.copy()
vgg2.conv2_1 = vggall.conv2_1.copy()
vgg2.conv2_2 = vggall.conv2_2.copy()
# Submodel for layer 3
vgg3 = VGGNetLayer3()
vgg3.conv3_1 = vggall.conv3_1.copy()
vgg3.conv3_2 = vggall.conv3_2.copy()
vgg3.conv3_3 = vggall.conv3_3.copy()
# try:
# train(model, train_dataset_Transform, test_dataset_Transform, log_name='VGG_SGD_NoSE_Transform_lr'+str(lr), n_epochs=args.epoch, optimizer=sgd, gpu_available=args.gpu)
# except KeyboardInterrupt:
# pass
#
# for lr in lrs:
# model = VGGNet(se_block=False)
# adam = torch.optim.Adam(params=model.parameters(), lr=lr)
# print('VGG_Adam_NoSE_Transform_lr'+str(lr)+':')
# try:
# train(model, train_dataset_Transform, test_dataset_Transform, log_name='VGG_Adam_NoSE_Transform_lr'+str(lr), n_epochs=args.epoch, optimizer=adam, gpu_available=args.gpu)
# except KeyboardInterrupt:
# pass
for lr in lrs:
model = VGGNet(se_block=True)
sgd = torch.optim.SGD(params=model.parameters(),
lr=lr,
momentum=0.9,
nesterov=True)
print('VGG_SGD_SE_Transform_lr' + str(lr) + ':')
try:
train(model,
train_dataset_Transform,
test_dataset_Transform,
log_name='VGG_SGD_SE_Transform_lr' + str(lr),
n_epochs=args.epoch,
optimizer=sgd,
gpu_available=args.gpu)
except KeyboardInterrupt:
pass
#!/usr/bin/python # -*- coding: UTF-8 -*- """ @author: Adam Wiveion @contact: [email protected] @time: 2021/1/9 13:20 """ import torch from VGGNet import VGGNet model = VGGNet(num_classes=10, version='vgg16') input = torch.randn(20,3,224,224) output = model(input) print(model) print(output.shape)