def get_resnet_symbol(num_res):
resnet = resnet18_v1(pretrained=True)
resnet1 = resnet.features
data = mx.sym.Variable("data")
out = resnet1(data)
all_layers = out.get_internals()
sym0 = all_layers[43]
sym1 = all_layers[84]
sym2 = all_layers[125]
sym3 = all_layers[166]
resnet_symbol = mx.sym.Group([sym0, sym1, sym2, sym3])
length_prefix = len(resnet.name + '_')
return resnet_symbol[:num_res], length_prefix
def _model(self):
gpu_count = mx.context.num_gpus()
ctx = mx.gpu() if gpu_count > 0 else mx.cpu()
if self.ml_model_name and self.ml_model_name.split(
'_')[0] == 'resnet18':
model = vision.resnet18_v1(classes=len(self.LABELS), ctx=ctx)
else:
model = vision.mobilenet_v2_1_0(classes=len(self.LABELS), ctx=ctx)
model_path = Path(self.ml_model.path) / Path(
os.listdir(self.ml_model.path)[0])
model.load_parameters(str(model_path), ctx=ctx)
def get_value(img: Array3D) -> Tuple[Union[str, Tuple], float]:
data = img.reshape((1, ) + img.shape)
data = mx.nd.array(data)
scores = model(mx.nd.array(self.img_transforms(data),
ctx=ctx)).softmax().asnumpy()
val = self.LABELS[int(np.argmax(scores, axis=1)[0])]
prob = scores[0][int(np.argmax(scores, axis=1)[0])]
return val, prob
return get_value
def compile_model(self):
if device == 'vta':
self.remote = rpc.connect(self.pynq_addr, 9091)
vta.reconfig_runtime(self.remote)
vta.program_fpga(self.remote, bitstream=None)
else:
self.remote = rpc.LocalSession()
self.ctx = self.remote.ext_dev(
0) if device == 'vta' else self.remote.cpu(0)
# Load pre-configured AutoTVM schedules
with autotvm.tophub.context(target):
# Populate the shape and data type dictionary for ResNet input
dtype_dict = {'data': 'float32'}
shape_dict = {'data': (env.BATCH, 3, 224, 224)}
gluon_model = vision.resnet18_v1(
pretrained=True, ctx=ctx
).features if args.nonsplit else splitnet.resnet18_v1_split(
self.id + 1)
# Measure build start time
build_start = time.time()
# Start front end compilation
mod, params = relay.frontend.from_mxnet(gluon_model, shape_dict)
# Update shape and type dictionary
shape_dict.update({k: v.shape for k, v in params.items()})
dtype_dict.update({k: str(v.dtype) for k, v in params.items()})
# Perform quantization in Relay
with relay.quantize.qconfig(global_scale=8.0,
skip_conv_layers=[0]):
relay_prog = relay.quantize.quantize(mod['main'],
params=params)
# Perform graph packing and constant folding for VTA target
if target.device_name == 'vta':
assert env.BLOCK_IN == env.BLOCK_OUT
relay_prog = graph_pack(relay_prog,
env.BATCH,
env.BLOCK_OUT,
env.WGT_WIDTH,
start_name=start_pack,
stop_name=stop_pack)
# Compile Relay program with AlterOpLayout disabled
with relay.build_config(opt_level=3,
disabled_pass={'AlterOpLayout'}):
if target.device_name != 'vta':
graph, lib, params = relay.build(
relay_prog,
target=target,
params=params,
target_host=env.target_host)
else:
with vta.build_config():
graph, lib, params = relay.build(
relay_prog,
target=target,
params=params,
target_host=env.target_host)
self.params = params
# Measure Relay build time
build_time = time.time() - build_start
print(f'inference graph for thread {self.id} built in {0:.4f}s!'.
format(build_time))
# Send the inference library over to the remote RPC server
temp = util.tempdir()
lib.save(temp.relpath('graphlib.o'))
self.remote.upload(temp.relpath('graphlib.o'))
lib = self.remote.load_module('graphlib.o')
# Graph runtime
self.m = graph_runtime.create(graph, lib, self.ctx)
ans.append('{}: {:.2f}%'.format(category,
probability.asscalar() * 100))
return ans
# parse command line arguments
parser = argparse.ArgumentParser(
description='live webcam demo for split ResNet')
parser.add_argument('--nonsplit', action='store_true', default=False)
args = parser.parse_args()
ctx = mx.cpu()
# get dense layer
if args.nonsplit:
dense = vision.resnet18_v1(pretrained=True, ctx=ctx).output
else:
dense = gluon.nn.Dense(1000)
dense.load_parameters('params/dense-1.params', ctx=ctx)
#get categories for imagenet
categories = np.array(json.load(open('image_net_labels.json', 'r')))
assert tvm.module.enabled('rpc')
# Load VTA parameters from the vta/config/vta_config.json file
env = vta.get_env()
# device, `vta` or `cpu`
device = 'vta'
target = env.target if device == 'vta' else env.target_vta_cpu
ctx = mx.cpu(store.local_rank) if args.no_cuda else mx.gpu(store.local_rank)
# Load the training data
train_data = gluon.data.DataLoader(gluon.data.vision.CIFAR10(train=True,
transform=transform), args.batch_size,
sampler=SplitSampler(50000,
num_workers,
store.rank))
# Load the test data
test_data = gluon.data.DataLoader(gluon.data.vision.CIFAR10(train=False,
transform=transform),
args.batch_size, shuffle=False)
# Load ResNet18 model from GluonCV model zoo
net = vision.resnet18_v1()
# Initialize the parameters with Xavier initializer
net.initialize(mx.init.Xavier(), ctx=ctx)
# Use Adam optimizer. Ask trainer to use the distributor kv store.
trainer = gluon.Trainer(net.collect_params(), optimizer='adam',
optimizer_params={'learning_rate': args.lr},
kvstore=store)
train_metric = mx.gluon.metric.Accuracy()
# Run as many epochs as required
for epoch in range(args.epochs):
tic = time.time()
train_metric.reset()
##################
# 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_v1(classes=10, pretrained=False, ctx=ctx)
# net = vision.resnet34_v1(classes=10, pretrained=False, ctx=ctx)
# net = vision.resnet50_v1(classes=10, pretrained=False, ctx=ctx)
# net = vision.resnet101_v1(classes=10, pretrained=False, ctx=ctx)
# net = vision.resnet152_v1(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)
return train_transform, val_transform
def get_imagenet_iterator(root, batch_size, num_workers, data_shape=224, dtype='float32'):
"""Dataset loader with preprocessing."""
train_dir = os.path.join(root, 'train')
train_transform, val_transform = get_imagenet_transforms(data_shape, dtype)
logging.info("Loading image folder %s, this may take a bit long...", train_dir)
train_dataset = ImageFolderDataset(train_dir, transform=train_transform)
train_data = DataLoader(train_dataset, batch_size, shuffle=True,
last_batch='discard', num_workers=num_workers)
val_dir = os.path.join(root, 'val')
if not os.path.isdir(os.path.expanduser(os.path.join(root, 'val', 'n01440764'))):
user_warning = 'Make sure validation images are stored in one subdir per category, a helper script is available at https://git.io/vNQv1'
raise ValueError(user_warning)
logging.info("Loading image folder %s, this may take a bit long...", val_dir)
val_dataset = ImageFolderDataset(val_dir, transform=val_transform)
val_data = DataLoader(val_dataset, batch_size, last_batch='keep', num_workers=num_workers)
return DataLoaderIter(train_data, dtype), DataLoaderIter(val_data, dtype)
resnet18 = vision.resnet18_v1(pretrained=True)
alexnet = vision.alexnet(pretrained=True)
inception = vision.inception_v3(pretrained=True)
#squeezenet = vision.squeezenet1_0()
#densenet = vision.densenet_161()
get_imagenet_iterator("c:\\data\\images", batch_size, num_workers, data_shape=224, dtype='float32'):
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) #####################################
import json
import matplotlib.pyplot as plt
import mxnet as mx
from mxnet import gluon, nd
from mxnet.gluon.model_zoo import vision
import numpy as np
ctx = mx.cpu()
densenet121 = vision.densenet121(pretrained=True, ctx=ctx)
mobileNet = vision.mobilenet0_5(pretrained=True, ctx=ctx)
resnet18 = vision.resnet18_v1(pretrained=True, ctx=ctx)
mx.test_utils.download(
'https://raw.githubusercontent.com/dmlc/web-data/master/mxnet/doc/tutorials/onnx/image_net_labels.json'
)
categories = np.array(json.load(open('image_net_labels.json', 'r')))
# filename = mx.test_utils.download('https://github.com/dmlc/web-data/blob/master/mxnet/doc/tutorials/onnx/images/dog.jpg?raw=true', fname='dog.jpg')
filename = 'scorp.jpg'
image = mx.image.imread(filename)
plt.imshow(image.asnumpy())
plt.show()
# Read the image: this will return a NDArray shaped as (image height, image width, 3), with the three channels in RGB order.
# Resize the shorter edge of the image 224.
# Crop, using a size of 224x224 from the center of the image.
# Shift the mean and standard deviation of our color channels to match the ones of the dataset the network has been trained on.
# Transpose the array from (Height, Width, 3) to (3, Height, Width).
# Load the training data
cifar10_data = gluon.data.vision.CIFAR10(train=True, transform=transform)
train_data = gluon.data.DataLoader(cifar10_data,
batch_size,
sampler=SplitSampler(
len(cifar10_data), store.num_workers,
store.rank))
# Load the test data
test_data = gluon.data.DataLoader(gluon.data.vision.CIFAR10(
train=False, transform=transform),
batch_size,
shuffle=False)
# Use ResNet from model zoo
net = vision.resnet18_v1(pretrained=False, ctx=ctx)
# Initialize the parameters with Xavier initializer
net.collect_params().initialize(mx.init.Xavier(), ctx=ctx)
# SoftmaxCrossEntropy is the most common choice of loss function for multiclass classification
softmax_cross_entropy = gluon.loss.SoftmaxCrossEntropyLoss()
# Use Adam optimizer. Ask trainer to use the distributer kv store.
trainer = gluon.Trainer(net.collect_params(),
'adam', {'learning_rate': .001},
kvstore=store)
# Evaluate accuracy of the given network using the given data
def evaluate_accuracy(data_iterator, net):
# img, label = batch.data[0][3*i+j], batch.label[0][3*i+j]
# img = img.transpose((1,2,0)) * RGB_MEAN + RGB_STD
# img = img.clip(0,255).asnumpy()/255
# fig = figs[i][j]
# fig.imshow(img)
# rect = box_to_rect(label[0][1:5]*DATA_SHAPE , 'red', 2)
# fig.add_patch(rect)
# fig.axes.get_xaxis().set_visible(False)
# fig.axes.get_yaxis().set_visible(False)
# plt.show()
# Step 2: 定义网络模型
# In[106]:
pretrained = vision.resnet18_v1(pretrained=True).features
net = nn.HybridSequential()
for i in range(8):
net.add(pretrained[i])
net.add(nn.GlobalAvgPool2D())
Dense_layer = nn.Dense(units=4)
Dense_layer.initialize()
net.add(Dense_layer)
#net.load_parameters('models/model_5.params')
net
# In[112]:
#check_result:
test_input = batch.data[0]
def transform(data, label, augs):
data = data.astype('float32')
for aug in augs:
data = aug(data)
data = nd.transpose(data, (2, 0, 1))
return data, nd.array([label]).asscalar().astype('float32')
train_imgs = gluon.data.vision.ImageFolderDataset(
data_dir + '/food/train',
transform=lambda X, y: transform(X, y, train_augs))
test_imgs = gluon.data.vision.ImageFolderDataset(
data_dir + '/food/test', transform=lambda X, y: transform(X, y, test_augs))
pretrained_net = models.resnet18_v1(pretrained=True)
finetune_net = models.resnet18_v1(classes=2)
finetune_net.features = pretrained_net.features
finetune_net.output.initialize(init.Xavier())
def train(net, ctx, batch_size=64, epochs=1, learning_rate=0.01, wd=0.001):
train_data = gluon.data.DataLoader(train_imgs, batch_size, shuffle=True)
test_data = gluon.data.DataLoader(test_imgs, batch_size)
# 确保net的初始化在ctx上
net.collect_params().reset_ctx(ctx)
net.hybridize()
loss = gluon.loss.SoftmaxCrossEntropyLoss()
# 训练
trainer = gluon.Trainer(net.collect_params(), 'sgd', {
image.CenterCropAug((32,32))
]
batch_size = 64
learning_rate=.1
num_epochs = 50
randseed = 4
ctx = utils.try_all_gpus()
loss = gluon.loss.SoftmaxCrossEntropyLoss()
train_data, test_data, data_num = get_data('D:/lagBear/S***N/finally_data/cnn_data.mat',randseed,batch_size=batch_size,train_augs=train_augs)
pre_net = models.resnet18_v1(ctx = ctx,pretrained=True,prefix = 'sperm_3t2class_')
pre_net.output
pre_net.features[0].weight.data()[0][0]
net = models.resnet18_v1(classes=2,prefix = 'sperm_3t2class_',ctx = ctx)
net.features = pre_net.features
net.initialize(ctx=ctx)
net.output.initialize(init.Xavier())
net.hybridize()
trainer = gluon.Trainer(net.collect_params(),
'sgd', {'learning_rate': learning_rate})
return iter(indices)
def __len__(self):
return self.part_len
# Load the training data
train_data = gluon.data.DataLoader(gluon.data.vision.CIFAR10(train=True, transform=transform), batch_size,
sampler=SplitSampler(50000, store.num_workers, store.rank))
# Load the test data
test_data = gluon.data.DataLoader(gluon.data.vision.CIFAR10(train=False, transform=transform),
batch_size, shuffle=False)
# Use ResNet from model zoo
net = vision.resnet18_v1()
# Initialize the parameters with Xavier initializer
net.collect_params().initialize(mx.init.Xavier(), ctx=ctx)
# SoftmaxCrossEntropy is the most common choice of loss function for multiclass classification
softmax_cross_entropy = gluon.loss.SoftmaxCrossEntropyLoss()
# Use Adam optimizer. Ask trainer to use the distributor kv store.
trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': .001}, kvstore=store)
# Evaluate accuracy of the given network using the given data
def evaluate_accuracy(data_iterator, network):
""" Measure the accuracy of ResNet
mx.sym.Convolution(data=channels[i],
weight=skernel,
num_filter=1,
kernel=(3, 3),
pad=(1, 1),
no_bias=True,
stride=(1, 1)) for i in range(nchannel)
])
kernel = mx.nd.array(
np.array([[0, -1, 0], [-1, 4, -1], [0, -1, 0]]).reshape(
(1, 1, 3, 3)), ctx) / 8.0
out = out * tv_weight
return out.bind(ctx, args={"img": img, "kernel": kernel})
resnet = resnet18_v1(pretrained=True)
flag = 'vgg' #args.net
if flag == 'vgg':
vgg_symbol = symbol.descriptor_symbol(args.num_res)
pretrained = mx.nd.load(VGGPATH)
arg_names = vgg_symbol.list_arguments()
elif flag == 'resnet':
resnet_symbol, length_prefix = symbol.get_resnet_symbol(
resnet, args.num_res)
pretrained = mx.nd.load('../resnet18.params')
arg_names = resnet_symbol.list_arguments()
aux_names = resnet_symbol.list_auxiliary_states()
aux_dict = {}
for name in aux_names:
if name == "data":
