def get_model_resnet18_v2(classes_num, ctx): pretrained_net = models.resnet18_v2(pretrained=True) # print(pretrained_net) finetune_net = models.resnet18_v2(classes=classes_num) # 输出为classes_num个类 finetune_net.features = pretrained_net.features # 特征设置为resnet18_v2的特征 finetune_net.output.initialize(init.Xavier(), ctx=ctx) # 对输出层做初始化 finetune_net.collect_params().reset_ctx(ctx) # 设置CPU或GPU finetune_net.hybridize() # gluon特征,运算转成符号运算,提高运行速度 return finetune_net
def test_tensorrt_resnet18_feature_vect(): print("downloading sample input") input_data = get_image(url) gluon_resnet18 = vision.resnet18_v2(pretrained=True) gluon_resnet18.hybridize() gluon_resnet18.forward(input_data) gluon_resnet18.export(model_file_name) sym, arg_params, aux_params = mx.model.load_checkpoint(model_file_name, 0) executor = sym.simple_bind(ctx=mx.gpu(), data=batch_shape, grad_req='null', force_rebind=True) executor.copy_params_from(arg_params, aux_params) y = executor.forward(is_train=False, data=input_data) trt_sym = sym.get_backend_symbol('TensorRT') mx.contrib.tensorrt.init_tensorrt_params(trt_sym, arg_params, aux_params) original_precision_value = mx.contrib.tensorrt.get_use_fp16() try: mx.contrib.tensorrt.set_use_fp16(True) executor = trt_sym.simple_bind(ctx=mx.gpu(), data=batch_shape, grad_req='null', force_rebind=True) executor.copy_params_from(arg_params, aux_params) y_trt = executor.forward(is_train=False, data=input_data) mx.contrib.tensorrt.set_use_fp16(False) executor = trt_sym.simple_bind(ctx=mx.gpu(), data=batch_shape, grad_req='null', force_rebind=True) executor.copy_params_from(arg_params, aux_params) y_trt_fp32 = executor.forward(is_train=False, data=input_data) no_trt_output = y[0].asnumpy()[0] trt_output = y_trt[0].asnumpy()[0] trt_fp32_output = y_trt_fp32[0].asnumpy()[0] assert_almost_equal(no_trt_output, trt_output, 1e-1, 1e-2) assert_almost_equal(no_trt_output, trt_fp32_output, 1e-4, 1e-4) finally: mx.contrib.tensorrt.set_use_fp16(original_precision_value)
def test_tensorrt_resnet18_feature_vect(): print("downloading sample input") input_data = get_image(url) gluon_resnet18 = vision.resnet18_v2(pretrained=True) gluon_resnet18.hybridize() gluon_resnet18.forward(input_data) gluon_resnet18.export(model_file_name) sym, arg_params, aux_params = mx.model.load_checkpoint(model_file_name, 0) executor = sym.simple_bind(ctx=mx.gpu(), data=batch_shape, grad_req='null', force_rebind=True) executor.copy_params_from(arg_params, aux_params) y = executor.forward(is_train=False, data=input_data) trt_sym = sym.get_backend_symbol('TensorRT') arg_params, aux_params = mx.contrib.tensorrt.init_tensorrt_params(trt_sym, arg_params, aux_params) original_precision_value = mx.contrib.tensorrt.get_use_fp16() try: mx.contrib.tensorrt.set_use_fp16(True) executor = trt_sym.simple_bind(ctx=mx.gpu(), data=batch_shape, grad_req='null', force_rebind=True) executor.copy_params_from(arg_params, aux_params) y_trt = executor.forward(is_train=False, data=input_data) mx.contrib.tensorrt.set_use_fp16(False) executor = trt_sym.simple_bind(ctx=mx.gpu(), data=batch_shape, grad_req='null', force_rebind=True) executor.copy_params_from(arg_params, aux_params) y_trt_fp32 = executor.forward(is_train=False, data=input_data) no_trt_output = y[0].asnumpy()[0] trt_output = y_trt[0].asnumpy()[0] trt_fp32_output = y_trt_fp32[0].asnumpy()[0] assert_almost_equal(no_trt_output, trt_output, 1e-1, 1e-2) assert_almost_equal(no_trt_output, trt_fp32_output, 1e-4, 1e-4) finally: mx.contrib.tensorrt.set_use_fp16(original_precision_value)
def get_net(model_name, context): if model_name == 'FCN': num_classes = 21 pretrained_net = vision.resnet18_v2(pretrained=True, ctx=context) net = gluon.nn.HybridSequential() for layer in pretrained_net.features[:-2]: net.add(layer) net.add( gluon.nn.Conv2D(num_classes, kernel_size=1), gluon.nn.Conv2DTranspose(num_classes, kernel_size=64, padding=16, strides=32)) net[-1].initialize(init.Constant( bilinear_kernel(num_classes, num_classes, 64)), ctx=context) net[-2].initialize(init=init.Xavier(), ctx=context) input_shape = (1, 3, 320, 480) label_shape = (1, 320, 480) loss_axis = 1 else: net = vision.get_model(model_name, classes=10) net.initialize(mx.init.Xavier(), ctx=context) input_shape = (1, 1, 224, 224) label_shape = 1 loss_axis = -1 return net, input_shape, label_shape, loss_axis
def train_net(k): his_testacc=[] his_trainacc=[] for n in range(k): pretrained_net = models.resnet18_v2(pretrained=True) net = models.resnet18_v2(classes=2) net.features = pretrained_net.features net.output.initialize(init.Xavier()) net.collect_params().reset_ctx(ctx) # resnet = utils.ResNet(2,1) # net = utils.Perceptron(2) # net.initialize(ctx=ctx) #use k cross validation train_index = list(range(0,int(n*1000/k)))+list(range(int((n+1)*1000/k),1000)) train_data_array = data[train_index] label_train_array = label[train_index] test_data_array = data[int(n*1000/k):int((n+1)*1000/k)] label_test_array = label[int(n*1000/k):int((n+1)*1000/k)] #use data augmentation train_data_array_ori = nd.transpose(train_data_array, (0,2,3,1))*255 train_data_array = nd.stack(*[utils.apply_aug_list(d,utils.test_augs) for d in train_data_array_ori]) train_data_array_aug = nd.stack(*[utils.apply_aug_list(d,utils.train_augs) for d in train_data_array_ori]) train_data_array = nd.stack(train_data_array,train_data_array_aug).reshape([int(2*(1000-1000/k)),utils.size,utils.size,3]) train_data_array = nd.transpose(train_data_array, (0,3,1,2))/255 label_train_array = nd.stack(label_train_array,label_train_array).reshape([int(2*(1000-1000/k))]) test_data_array = nd.transpose(test_data_array, (0,2,3,1))*255 test_data_array = nd.stack(*[utils.apply_aug_list(d,utils.test_augs) for d in test_data_array]) test_data_array = nd.transpose(test_data_array, (0,3,1,2))/255 #load trainging data and test data train_data = mx.io.NDArrayIter(data = train_data_array,label=label_train_array,batch_size=batch_size,shuffle=True) test_data = mx.io.NDArrayIter(data = test_data_array,label=label_test_array,batch_size=batch_size,shuffle=True) trainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate':.008 , 'wd':.3 }) train_acc , acc, net_tem = utils.train(train_data, test_data,batch_size ,net, loss, trainer, ctx, num_epochs=epochs) his_testacc.append(acc) his_trainacc.append(train_acc) net_tem.save_params(os.path.join(path_net,str(n)))#save net return his_trainacc ,his_testacc
def build_dictionary(): #model = keras.applications.vgg16.VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3), pooling='avg') ctx = mx.gpu() if len(mx.test_utils.list_gpus()) else mx.cpu() net = vision.resnet18_v2(pretrained=True, ctx=ctx).features net.hybridize() net(mx.nd.ones((1, 3, 224, 224), ctx=ctx)) net.export(join('mms', 'visualsearch')) block_blob_service = BlockBlobService( account_name='hackathonnetshoes', account_key= '1syRJGXjNT8s3eZR1lCLTuo7OCDm6LfMDAMNh1ej8Krs8mpwy3EeheTq1bnXCehOTIo0Glffu5MKZhskULys6A==' ) generator = block_blob_service.list_blobs('hackthonns') idx = 0 with open('/../../grupo2storage2/features/dnn/features_mx.pickle', 'wb') as features_handle: with open('/../../grupo2storage2/features/dnn/skus_mx.pickle', 'wb') as sku_handle: for blob in generator: if (not blob.name.endswith('.jpg')): continue if ('produtos' not in blob.name): continue print('[{0}] processing {1}'.format( idx, os.path.basename(blob.name))) blob = block_blob_service.get_blob_to_bytes( 'hackthonns', blob.name) image_file_in_mem = io.BytesIO(blob.content) img = load_img(image_file_in_mem) img = img_to_array(img) img = transform(nd.array(img)) feature = img.expand_dims(axis=0).as_in_context(ctx) print(feature) sku = os.path.basename(blob.name).split('.')[0] pickle.dump(feature, features_handle, protocol=pickle.HIGHEST_PROTOCOL) pickle.dump(sku, sku_handle, protocol=pickle.HIGHEST_PROTOCOL) idx += 1
def __init__(self, features_file, skus_file): #self._model = keras.applications.vgg16.VGG16(weights='imagenet', # include_top=False, # input_shape=(224, 224, 3), # pooling='avg') #self.graph = tf.get_default_graph() self.ctx = mx.gpu() if len(mx.test_utils.list_gpus()) else mx.cpu() self.net = vision.resnet18_v2(pretrained=True, ctx=self.ctx).features print('finishing initialization') # self._preprocess = keras.applications.vgg16.preprocess_input self._load_files(features_file, skus_file)
def __init__(self, is_color, img_sample_sz=[], size_mode='same'): super().__init__(is_color) use_for_color = settings.cnn_params.get('useForColor', True) use_for_gray = settings.cnn_params.get('useForGray', True) self.use_feature = (use_for_color and is_color) or (use_for_gray and not is_color) self.net = vision.resnet18_v2(pretrained=True, ctx=mx.cpu(0)) self.compressed_dim = settings.cnn_params['compressed_dim'] self.cell_size = np.array([4, 16]) self.penalty = np.zeros((2, 1)) self.nDim = np.array([64, 256]) self.img_sample_sz = self._set_size(img_sample_sz, size_mode) self.data_sz = np.ceil(self.img_sample_sz / self.cell_size[:, None])
def set_p(): global p global net global datasets if not p: p = hnswlib.Index(space='l2', dim=EMBEDDING_SIZE) print config_dic idx_loc = config_dic.get("idx_loc") print idx_loc p.load_index(idx_loc) p.set_ef(300) net = vision.resnet18_v2(pretrained=True, ctx=ctx) net = net.features pkl_loc = config_dic.get("idx_dir") + "dataset.pkl" datasets = pickle.load(open(pkl_loc, "rb"))
def __init__(self, class_num, **kwargs): super(FCNet, self).__init__(**kwargs) pretrained_net = modelv.resnet18_v2(ctx=mx.gpu(), pretrained=True) self.net = gluon.nn.HybridSequential() for layer in pretrained_net.features[:-2]: with self.net.name_scope(): # add name_scope() self.net.add(layer) with self.net.name_scope(): self.net.add(gluon.nn.Conv2D(channels=class_num, kernel_size=1), gluon.nn.Conv2DTranspose(channels=class_num, kernel_size=64, padding=16, strides=32)) self.net[-2].initialize(init=mx.init.Xavier(), ctx=mx.gpu()) self.net[-1].initialize(init=mx.init.Bilinear(), ctx=mx.gpu())
def getNetwork(nb_class): resnet_ = vision.resnet18_v2(pretrained=False, classes=nb_class) #resnet_18.collect_params().initialize(mx.init.Xavier(magnitude=0.5), ctx=ctx) return resnet_
net = nn.Sequential() with net.name_scope(): # net.add(nn.Conv2D(1,3,padding=1)) net.add(nn.Flatten()) net.add(nn.Dropout(.5)) net.add(nn.Dense(256)) net.add(nn.BatchNorm()) net.add(nn.Activation('relu')) net.add(nn.Dense(num_class)) return net #===============define a pretrained network====== from mxnet.gluon.model_zoo import vision as models pretrained_net = models.resnet18_v2(pretrained=True) from mxnet import init finetune_net = models.resnet18_v2(classes=2) finetune_net.features = pretrained_net.features finetune_net.output.initialize(init.Xavier()) class DHash(object): @staticmethod def calculate_hash(image): """ 计算图片的dHash值 :param image: PIL.Image :return: dHash值,string类型 """
pad=4, num_parts=store.num_workers, part_index=store.rank) test_data = mx.io.ImageRecordIter( path_imgrec="./cifar/cifar10_val.rec", # mean_img = "data/cifar/mean.bin", resize=-1, rand_crop=False, rand_mirror=False, pad=4, data_shape=(3, 32, 32), batch_size=batch_size) # Use ResNet from model zoo net = vision.resnet18_v2() # Initialize the parameters with Xavier initializer net.collect_params().initialize(mx.init.Xavier(magnitude=2), ctx=ctx) # Use Adam optimizer. Ask trainer to use the distributer kv store. trainer = gluon.Trainer(net.collect_params(), 'adam', { 'learning_rate': learning_rate, 'rescale_grad': 1.0 / (batch_size * store.num_workers), 'clip_gradient': 10 }, kvstore=store)
import mxnet as mx import time import gluoncv from mxnet import nd, autograd from mxnet import gluon from mxnet.gluon import nn inputShape = (1, 3, 224, 224) from mxnet.gluon.model_zoo import vision alexnet = vision.alexnet() inception = vision.inception_v3() resnet18v1 = vision.resnet18_v1() resnet18v2 = vision.resnet18_v2() squeezenet = vision.squeezenet1_0() densenet = vision.densenet121() mobilenet = vision.mobilenet0_5() ############### 그래프 ############### import gluoncv gluoncv.utils.viz.plot_network(resnet18v1, shape=inputShape) #####################################
def getNetwork(nb_class): resnet_18 = vision.resnet18_v2(pretrained=False,classes=nb_class) return resnet_18
import mxnet as mx from mxnet.gluon.model_zoo import vision import time import os batch_shape = (1, 3, 224, 224) resnet18 = vision.resnet18_v2(pretrained=True) resnet18.hybridize() resnet18.forward(mx.nd.zeros(batch_shape)) resnet18.export('resnet18_v2') sym, arg_params, aux_params = mx.model.load_checkpoint('resnet18_v2', 0) # Create sample input input = mx.nd.zeros(batch_shape) # Execute with MXNet os.environ['MXNET_USE_TENSORRT'] = '0' executor = sym.simple_bind(ctx=mx.gpu(0), data=batch_shape, grad_req='null', force_rebind=True) executor.copy_params_from(arg_params, aux_params) # Warmup print('Warming up MXNet') for i in range(0, 10): y_gen = executor.forward(is_train=False, data=input) y_gen[0].wait_to_read() # Timing print('Starting MXNet timed run')
voc_test = VOCSegDataset(False, input_shape) batch_size = 5 train_data = gluon.data.DataLoader(voc_train, batch_size, shuffle=True, last_batch='discard') test_data = gluon.data.DataLoader(voc_test, batch_size, last_batch='discard') #for data, label in train_data: # print(data.shape) # print(label.shape) # break from mxnet.gluon.model_zoo import vision as models pretrained_net = models.resnet18_v2(pretrained=True) from mxnet.gluon import nn #conv = nn.Conv2D(10, kernel_size=4, padding=1, strides=2) #conv_trans = nn.Conv2DTranspose(3, kernel_size=4, padding=1, strides=2) #conv.initialize() #conv_trans.initialize() #x = nd.random.uniform(shape=(1,3,64,64)) #y = conv(x) #print('Input:', x.shape) #print('After conv:', y.shape) #print('After transposed conv', conv_trans(y).shape) net = nn.HybridSequential() for layer in pretrained_net.features[:-2]:
average_acc += his_testacc[i][-1] plt.xlabel('epoch') plt.ylabel('test_acc') plt.legend() plt.show() print('The average training accuracy is : %.4f , the average test accuracy is : %.4f '% (np.mean(train_acc) , average_acc/k_cross)) max_acc = 0 max_k = 0 # compare the acc of the 10 net on the entire data , get the best classifier for i in range(k_cross): # net = utils.Perceptron(2) net = models.resnet18_v2(classes=2) test_data_array = data for image in test_data_array: image_tem = nd.transpose(image,axes=(1,2,0))*255 image = utils.apply_aug_list(image_tem,utils.test_augs) image = nd.transpose(image,(2,0,1))/255 test_data = mx.io.NDArrayIter(data = test_data_array,label=label,batch_size=batch_size,shuffle=True) net.load_params(os.path.join(path_net,str(i)) , ctx = ctx) if utils.evaluate_accuracy(test_data,net,ctx) > max_acc: max_acc = utils.evaluate_accuracy(test_data,net,ctx) max_k = i print('The best net is net%i , accuracy of the entire data is :%.4f '% (max_k , max_acc)) os.rename(os.path.join(path_net,str(max_k)),os.path.join(path_net,'bestnet_pretrained'))
def resnet18mxnetload(): net = vision.resnet18_v2(pretrained=True) net.hybridize() return net
################## # Hyperparameter # #----------------# ctx = mx.cpu() lr = 0.05 epochs = 10 momentum = 0.9 batch_size = 64 #----------------# # Hyperparameter # ################## ################## model from mxnet.gluon.model_zoo import vision net = vision.resnet18_v2(classes=10, pretrained=False, ctx=ctx) # net = vision.resnet34_v2(classes=10, pretrained=False, ctx=ctx) # net = vision.resnet50_v2(classes=10, pretrained=False, ctx=ctx) # net = vision.resnet101_v2(classes=10, pretrained=False, ctx=ctx) # net = vision.resnet152_v2(classes=10, pretrained=False, ctx=ctx) ################## 그래프 import gluoncv inputShape = (1, 3, 224, 224) gluoncv.utils.viz.plot_network(net, shape=inputShape) ##### 전처리 ############################################## def transformer(data, label): data = mx.image.imresize(data, 224, 224) data = mx.nd.transpose(data, (2, 0, 1))
for option in config['DEFAULT']: config_dic[option] = config.get('DEFAULT', option, raw=True) images_path = "images/" idx_loc = config_dic.get("idx_loc") idx_dir = config_dic.get("idx_dir") BATCH_SIZE = 256 EMBEDDING_SIZE = 512 SIZE = (224, 224) MEAN_IMAGE= mx.nd.array([0.485, 0.456, 0.406]) STD_IMAGE = mx.nd.array([0.229, 0.224, 0.225]) ctx = mx.cpu() net = vision.resnet18_v2(pretrained=True, ctx=ctx) net = net.features def transform(image, label): resized = mx.image.resize_short(image, SIZE[0]).astype('float32') cropped, crop_info = mx.image.center_crop(resized, SIZE) cropped /= 255. normalized = mx.image.color_normalize(cropped, mean=MEAN_IMAGE, std=STD_IMAGE) transposed = nd.transpose(normalized, (2,0,1)) return transposed, label empty_folder = tempfile.mkdtemp() # Create an empty image Folder Data Set dataset = ImageFolderDataset(root=empty_folder, transform=transform)
def main(): input_shape = (320, 480) voc_train = VOCSegDataset(True, input_shape) voc_test = VOCSegDataset(False, input_shape) batch_size = 4 train_data = gluon.data.DataLoader(voc_train, batch_size, shuffle=True, last_batch='discard') test_data = gluon.data.DataLoader(voc_test, batch_size, last_batch='discard') # ctx = common.ChoiceGpu() ctx = common.ChoiceCpu() pretrained_net1 = models.resnet18_v2(pretrained=True) # pretrained_net2 = GetNet(10, ctx=ctx) # pretrained_net3 = models.vgg13(pretrained=True) # pretrained_net2.load_parameters("train.params") net = nn.HybridSequential() for layer in pretrained_net1.features[:-2]: # for layer in pretrained_net2.net[:-2]: net.add(layer) num_classes = len(classes) with net.name_scope(): net.add( nn.Conv2D(num_classes, kernel_size=1), # nn.Conv2DTranspose(num_classes, kernel_size=4, padding=1, strides=2), # nn.Conv2DTranspose(num_classes, kernel_size=4, padding=1, strides=2), # nn.Conv2DTranspose(num_classes, kernel_size=4, padding=1, strides=2), # nn.Conv2DTranspose(num_classes, kernel_size=4, padding=1, strides=2), # nn.Conv2DTranspose(num_classes, kernel_size=4, padding=1, strides=2) # nn.Conv2DTranspose(num_classes, kernel_size=32, padding=8, strides=16) nn.Conv2DTranspose(channels=num_classes, kernel_size=64, padding=16, strides=32), ) conv_trans1 = net[-1] conv_trans1.initialize(init=init.Zero()) # conv_trans2 = net[-2] # conv_trans2.initialize(init=init.Zero()) # conv_trans3 = net[-3] # conv_trans3.initialize(init=init.Zero()) # conv_trans4 = net[-4] # conv_trans4.initialize(init=init.Zero()) # conv_trans5 = net[-5] # conv_trans5.initialize(init=init.Zero()) # net[-2].initialize(init=init.Xavier()) x = nd.zeros((batch_size, 3, *input_shape)) net(x) shape = conv_trans1.weight.data().shape conv_trans1.weight.set_data(bilinear_kernel(*shape[0:3])) conv_trans0 = net[1] print(conv_trans0.weight.data()) # print(conv_trans0.weight.data()) # # shape = conv_trans2.weight.data().shape # conv_trans2.weight.set_data(bilinear_kernel(*shape[0:3])) # # shape = conv_trans3.weight.data().shape # conv_trans3.weight.set_data(bilinear_kernel(*shape[0:3])) # # shape = conv_trans4.weight.data().shape # conv_trans4.weight.set_data(bilinear_kernel(*shape[0:3])) # # shape = conv_trans5.weight.data().shape # conv_trans5.weight.set_data(bilinear_kernel(*shape[0:3])) ctx = common.ChoiceGpu() net.collect_params().reset_ctx(ctx) net.load_parameters("train.params", ctx=ctx) loss = gluon.loss.SoftmaxCrossEntropyLoss(axis=1) if True: trainer = gluon.Trainer(net.collect_params(), 'sgd', { 'learning_rate': 1 / batch_size, 'wd': 1e-3 }) common.Train(train_data, 10, net, loss, trainer, batch_size, ctx) n = 6 imgs = [] data, label = ReadImage(train=False) for i in range(n): x = data[i] pred = label2image(predict(x, net, ctx)) imgs += [x, pred, label[i]] show_images(imgs, nrows=n, ncols=3, figsize=(6, 10)) print("ok")
isprs_test = ISPRSDataset(is_train=False, transform=None) # generate the dataloader trainloader = gluon.data.DataLoader(isprs_train, batch_size=args.batch_size, shuffle=True, last_batch='discard') testloader = gluon.data.DataLoader(isprs_test, batch_size=1, last_batch='discard') print(len(trainloader)) print(len(testloader)) # set the model info pretrained_model = models.resnet18_v2(pretrained=True, ctx=ctx) model = nn.HybridSequential() # build the layer for layer in pretrained_model.features[:-2]: model.add(layer) with model.name_scope(): model.add( nn.Conv2D(args.num_classes, kernel_size=1), nn.Conv2DTranspose(args.num_classes, kernel_size=64, padding=16, strides=32)) model[-2].initialize(init=init.Xavier(), ctx=ctx) model[-1].initialize(init=init.Constant(