def __init__(self):
LeNet.__init__(self, 28, 28)
#控制变量定义
self.learning_rate = 0.001
# 记录已经训练的次数
self.global_step = tf.Variable(0, trainable=False)
self.x = tf.placeholder(tf.float32, [None, 784])
self.label = tf.placeholder(tf.float32, [None, 10])
self.x_image = tf.reshape(self.x, [-1, 28, 28, 1])
#网路层次定义
self.layer1(5, 5, 32)
self.layer2(5, 5, 64)
self.fullConnLayer(int(1024))
self.outputLayer(10)
#计算参数定义
#loss
self.loss = -tf.reduce_sum(self.label * tf.log(self.y + 1e-10))
# minimize 可传入参数 global_step， 每次训练 global_step的值会增加1
# 因此，可以通过计算self.global_step这个张量的值，知道当前训练了多少步
self.train = tf.train.AdamOptimizer(self.learning_rate).minimize(
self.loss, global_step=self.global_step)
predict = tf.equal(tf.argmax(self.label, 1), tf.argmax(self.y, 1))
self.accuracy = tf.reduce_mean(tf.cast(predict, "float"))
def main():
transform = transforms.Compose([
transforms.Resize(
(32, 32)), #transforms.Resize((32,32))因为下载的图不一定是标准的，先转为32,32
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
'ship', 'truck')
net = LeNet() #实例化
net.load_state_dict(torch.load('Lenet.pth')) #载入权重文件
im = Image.open(
'luxing_cat.jpg') #通过PIL、numpy一般导入的格式为（height,width,channel）[H,W,C]
im = transform(im) # [C, H, W]
im = torch.unsqueeze(im, dim=0) # 加上batch维度（dim=0表示在最前面） [N, C, H, W]
with torch.no_grad():
outputs = net(im)
predict = torch.max(outputs, dim=1)[1].data.numpy()
print(classes[int(predict)])
#使用softmax
with torch.no_grad():
outputs = net(im)
predict = torch.softmax(outputs, dim=1) #dim=0是batch维度
print(predict)
def main():
transform = transforms.Compose([
transforms.Resize((32, 32)), # 因为下载的图片大小不一，所以先resize
transforms.ToTensor(), # ToTensor() 将 H*W*C的numpy 变为 C*H*W的tensor
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]) # 标准化处理
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
'ship', 'truck')
net = LeNet() # 实例化对象
net.load_state_dict(torch.load('Lenet.pth')) # 通过load_state_dict载入保存的权重文件
#im = Image.open('1.jpg') # PIL库的Image 打开图像，H*W*C
im = Image.open('./pytorch_classification/Test1_official_demo/1.jpg')
im = transform(
im
) # [C, H, W] # 如果要在网络中传播，必须变为tensor格式，所以transform变为C*H*W
im = torch.unsqueeze(
im, dim=0
) # [N, C, H, W] # ^ torch.unsqueeze(~~~ , dim=0)在第0维增加新的维度；变为N*C*H*W
with torch.no_grad(): # ^ 测试阶段，不需要求损失梯度，使用torch.no_grad()
outputs = net(im) # 图像传入网络中得到输出，输出的维度为[batch, 10]，只关注dim=1
predict = torch.max(outputs, dim=1)[1].data.numpy(
) # 找到第1个维度中最大的数，但是只关注其位置（即[1]，index），转化为numpy
predict1 = torch.softmax(outputs, dim=1) # 得到了概率分布
print(classes[int(predict)]) # 将index传入到classes就得到了类别
print(predict1) # 打印概率分布
def main():
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
# 50000张训练图片
# 第一次使用时要将download设置为True才会自动去下载数据集
train_set = torchvision.datasets.CIFAR10(root='./data', train=True,
download=False, transform=transform)
train_loader = torch.utils.data.DataLoader(train_set, batch_size=36,
shuffle=True, num_workers=0)
# 10000张验证图片
# 第一次使用时要将download设置为True才会自动去下载数据集
val_set = torchvision.datasets.CIFAR10(root='./data', train=False,
download=False, transform=transform)
val_loader = torch.utils.data.DataLoader(val_set, batch_size=5000,
shuffle=False, num_workers=0)
val_data_iter = iter(val_loader)
val_image, val_label = val_data_iter.next()
# classes = ('plane', 'car', 'bird', 'cat',
# 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
net = LeNet()
loss_function = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.001)
for epoch in range(5): # loop over the dataset multiple times
running_loss = 0.0
for step, data in enumerate(train_loader, start=0):
# get the inputs; data is a list of [inputs, labels]
inputs, labels = data
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = loss_function(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if step % 500 == 499: # print every 500 mini-batches
with torch.no_grad():
outputs = net(val_image) # [batch, 10]
predict_y = torch.max(outputs, dim=1)[1]
accuracy = (predict_y == val_label).sum().item() / val_label.size(0)
print('[%d, %5d] train_loss: %.3f test_accuracy: %.3f' %
(epoch + 1, step + 1, running_loss / 500, accuracy))
running_loss = 0.0
print('Finished Training')
save_path = './Lenet.pth'
torch.save(net.state_dict(), save_path)
def trainModel(EPOCH_NUM=50, save=False, show=False):
print("Train Start:")
net = LeNet().to(devices)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.RMSprop(net.parameters(),
lr=LR,
alpha=0.9,
eps=1e-08,
weight_decay=0,
momentum=0,
centered=False)
#x,trainloss,trainacc,testacc = [],[],[],[]
batch, batchloss = [], []
for epoch in range(EPOCH_NUM):
sum_loss = 0.0
acc = 0
iter = 0
for i, (inputs, labels) in enumerate(trainLoader):
inputs, labels = inputs.to(devices), labels.to(devices)
# forward and backward
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
sum_loss += loss.item()
_, pred = torch.max(outputs.data, 1)
acc += (pred == labels).sum()
iter = iter + 1
batch.append(i)
batchloss.append(loss.item())
if show == True:
plt.figure()
plt.plot(batch, batchloss, 'b')
plt.title('one epoch')
plt.xlabel('iteration')
plt.ylabel('loss')
plt.show()
# trainloss.append(sum_loss/iter)
# trainacc.append(100*acc/len(trainData))
# x.append(epoch)
print('Epoch [%d] : loss [%f]' % (epoch + 1, sum_loss / iter))
print('train accuracy = %f%%' % (100 * acc / len(trainData)))
#with torch.no_grad():
# correct = 0
# total = 0
# for data in testLoader:
# images, labels = data
# images, labels = images.to(devices), labels.to(devices)
# outputs = net(images)
# _, predicted = torch.max(outputs.data, 1)
# total += labels.size(0)
# correct += (predicted == labels).sum()
#print('test accuracy = %f%%'%(100*correct/total))
#testacc.append(100*correct/total)
if save == True:
torch.save(net.state_dict(), 'MNIST_Model.pth')
def train_lenet(device, dataset_path):
train_loader, valid_loader, test_loader = get_data_loaders(dataset_path)
model = LeNet(35)
optimizer = optim.Adam(model.parameters(),
lr=Consts.lr,
weight_decay=Consts.weight_decay)
loss_criterion = torch.nn.NLLLoss()
model.apply(weight_init)
model.to(device)
train_loss = []
val_loss = []
val_acc = []
for epoch in range(Consts.epochs):
t_loss = train(model, train_loader, optimizer, loss_criterion, device)
v_loss, v_acc = evaluation(model, valid_loader, loss_criterion, device)
torch.save(model.state_dict(), f'models/epoch-{epoch + 1}.pth')
train_loss.append(t_loss)
val_loss.append(v_loss)
val_acc.append(v_acc)
print(f'train loss in epoch {epoch + 1} is: {t_loss}')
print(f'validation loss in epoch {epoch + 1} is: {v_loss}')
print(f'validation accuracy in epoch {epoch + 1} is: {v_acc}')
plot_loss(train_loss, val_loss, val_acc)
test_loss, test_acc = test_model(model, test_loader, loss_criterion,
val_loss, device, 'models/')
def upload_image():
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
file = request.files['file']
if file.filename == '':
flash('No image selected for uploading')
return redirect(request.url)
if file and img_files(file.filename):
filename = secure_filename(file.filename)
image_source = request.files['file'].stream
# image_path = './static/images/' + filename
weight_path = './weight/mnist.pth'
model = LeNet().to(device)
image, preds = evaluation(image_source, weight_path, model)
image = image[0]
save_image(image, './static/images/' + filename)
preds = int(preds.cpu())
print('upload_image filename: ' + filename)
flash(f'Prediction: {preds}')
return render_template('upload.html', filename=filename)
else:
flash('Image extension must be -> png, jpg, jpeg, gif')
return redirect(request.url)
def main():
with open("config.json", "r") as f:
config = json.load(f)
# Load Cifar data
data = DataLoader(config)
# Create LeNet model
net = LeNet(config)
# Create trainer
trainer = Trainer(net.model, data, config)
# # Train model
# trainer.train()
# # Save LeNet model weights
# trainer.save_weights()
# Load weights
load_path = self.config["trainer"]["save_dir"] + self.config["experiment_name"] + \
"/" + self.config["trainer"]["save_trained_name"] + "_full.hdf5"
trainer.load_weights(load_path)
# Evaluate validation set
trainer.evaluate()
def quickdraw_predict():
quickdraw_animal_map = [
'ant', 'bat', 'bear', 'bee', 'bird', 'butterfly', 'camel', 'cat',
'cow', 'dog', 'dolphin', 'dragon', 'duck', 'elephant', 'fish',
'flamingo', 'frog', 'giraffe', 'hedgehog', 'horse', 'kangaroo', 'lion',
'lobster', 'mermaid', 'monkey', 'mosquito', 'mouse', 'octopus', 'owl',
'panda', 'penguin', 'pig', 'rabbit', 'raccoon', 'shark', 'sheep',
'snail', 'snake', 'spider', 'squirrel', 'teddy-bear', 'tiger', 'whale',
'zebra'
]
if request.method == 'POST':
quick_draw = request.form['url']
quick_draw = quick_draw[init_Base64:]
quick_draw_decoded = base64.b64decode(quick_draw)
# Fix later(to PIL version)
# Conver bytes array to PIL Image
# imageStream = io.BytesIO(draw_decoded)
# img = Image.open(imageStream)
quick_img = np.asarray(bytearray(quick_draw_decoded), dtype="uint8")
quick_img = cv2.imdecode(quick_img, cv2.IMREAD_GRAYSCALE)
quick_img = cv2.resize(quick_img, (28, 28),
interpolation=cv2.INTER_AREA)
quick_img = Image.fromarray(quick_img)
weight_path = './weight/quickdraw_90_animal.pth'
quick_model = LeNet(num_classes=44).to(device)
quick_img, quick_pred = quickdraw_evaluation(quick_img, weight_path,
quick_model)
quick_pred = int(quick_pred)
quick_label = quickdraw_animal_map[quick_pred]
return render_template('draw_quickdraw.html', prediction=quick_label)
def mnist_upload_image():
if request.method == 'POST':
mnist_f = request.files['file']
mnist_fname = secure_filename(mnist_f.filename)
if mnist_fname == '':
return redirect(url_for('mnist_view'))
os.makedirs('static', exist_ok=True)
mnist_f.save(os.path.join('static', mnist_fname))
mnist_img = Image.open(mnist_f, 'r')
mnist_img_display = mnist_img.resize(
(256, 256)) # To display large size image
mnist_display = 'display_' + mnist_fname
mnist_img_display.save(os.path.join('static', mnist_display))
weight_path = './weight/mnist.pth'
mnist_model = LeNet().to(device)
mnist_img, mnist_preds = mnist_evaluation(mnist_img, weight_path,
mnist_model)
mnist_preds = int(mnist_preds)
return render_template('upload_mnist.html',
num=mnist_preds,
filename=mnist_display)
def mnist_predict():
if request.method == 'POST':
mnist_draw = request.form['url']
mnist_draw = mnist_draw[init_Base64:]
mnist_draw_decoded = base64.b64decode(mnist_draw)
# Fix later(to PIL version)
# Conver bytes array to PIL Image
# imageStream = io.BytesIO(draw_decoded)
# img = Image.open(imageStream)
mnist_img = np.asarray(bytearray(mnist_draw_decoded), dtype="uint8")
mnist_img = cv2.imdecode(mnist_img, cv2.IMREAD_GRAYSCALE)
mnist_img = cv2.resize(mnist_img, (28, 28),
interpolation=cv2.INTER_AREA)
mnist_img = Image.fromarray(mnist_img)
weight_path = './weight/mnist.pth'
mnist_model = LeNet().to(device)
mnist_img, mnist_pred = mnist_evaluation(mnist_img, weight_path,
mnist_model)
mnist_pred = int(mnist_pred)
return render_template('draw_mnist.html', prediction=mnist_pred)
def runInference(test_input_x):
"""Test inference for given image"""
tf.reset_default_graph()
xs = tf.placeholder(tf.float32, [None, 784], name='input')
dropout = tf.placeholder(tf.float32, name='dropout')
#get the model logits
model_logits = LeNet(xs, dropout)
output = tf.argmax(tf.contrib.layers.softmax(model_logits), 1)
if not os.path.exists(model_ckpt_path):
raise ValueError('[!] model Checkpoint path does not exist...')
try:
with tf.Session() as sess:
print('[*] Reading checkpoint...')
saver = tf.train.Saver()
saver.restore(sess, os.path.join(model_ckpt_path, model_name))
output = sess.run(output,
feed_dict={
xs: test_input_x,
dropout: 0.0
})
except Exception as e:
print(e)
return output
def get_trace() -> AttrMap:
return reconstruct_static_trace_from_tf(
model_fn=lambda: LeNet(),
input_fn=lambda: tf.placeholder(tf.float32, shape=(1, 1, 28, 28)),
model_dir=tf.train.latest_checkpoint(abspath("tf/lenet/model/")),
density=threshold_to_density[threshold],
)
def __init__(self, args=None):
super().__init__()
self.writer = tX.SummaryWriter(log_dir=log_dir, comment='LeNet')
self.train_logger = None
self.eval_logger = None
self.args = args
self.step = 0
self.epoch = 0
self.best_error = float('Inf')
self.device = torch.device('cpu')
self.model = LeNet().to(self.device)
self.optimizer = optim.Adam(self.model.parameters(), lr=lr)
self.criterion = torch.nn.CrossEntropyLoss()
self.metric = metric
transform = tfs.Compose(
[tfs.ToTensor(),
tfs.Normalize((0.1307, ), (0.3081, ))])
train_dataset = MNIST(root='MNIST',
train=True,
transform=transform,
download=True)
train_loader = DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True)
test_dataset = MNIST(root='MNIST',
train=False,
transform=transform,
download=True)
test_loader = DataLoader(test_dataset,
batch_size=batch_size,
shuffle=False)
self.train_loader = train_loader
self.test_loader = test_loader
self.ckpt_dir = ckpt_dir
self.log_per_step = log_per_step
# self.eval_per_epoch = None
self.check_init()
def test(device, test_dataset_path, model_path):
test_loader = get_test_loader(test_dataset_path)
loss_criterion = torch.nn.NLLLoss()
model = LeNet(35)
if device.type == 'cpu':
model.load_state_dict(torch.load(model_path, map_location=device))
else:
model.load_state_dict(torch.load(model_path))
model.to(device)
test_model(model, test_loader, loss_criterion, [], device, None)
def Inference(index):
model = LeNet()
model.load_state_dict(torch.load('MNIST_Model.pth'))
img, label = testData.__getitem__(index)
img = img.unsqueeze(0)
output = model(img)
print(output)
output = output.tolist()
output = [i for i in output[0]]
x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
plt.figure()
plt.subplot(2, 1, 1)
plt.imshow(img.reshape(28, 28))
plt.subplot(2, 1, 2)
plt.ylim(0, 1)
plt.yticks([0, 0.2, 0.4, 0.6, 0.8, 1])
plt.xlim(0, 9)
plt.bar(x, output)
plt.show()
def main():
with open("config.json", "r") as f:
config = json.load(f)
## Prepare data
data = CifarDataset(config)
all_transforms = transforms.Compose(
[ToGrayscale(), Normalize(), ToTensor()])
train_data_transformed = CifarDataLoader(config,
data.X_train,
data.y_train,
transform=all_transforms)
train_loader = DataLoader(train_data_transformed,
batch_size=config["data_loader"]["batch_size"],
shuffle=False,
num_workers=4)
if config["validation"]["split"]:
valid_data_transformed = CifarDataLoader(config,
data.X_valid,
data.y_valid,
transform=all_transforms)
valid_loader = DataLoader(
valid_data_transformed,
batch_size=config["data_loader"]["batch_size"],
shuffle=False,
num_workers=4)
test_data_transformed = CifarDataLoader(config,
data.X_test,
data.y_test,
transform=all_transforms)
test_loader = DataLoader(test_data_transformed,
batch_size=config["data_loader"]["batch_size"],
shuffle=False,
num_workers=4)
## Create neural net
net = LeNet()
## Training
trainer = Trainer(model=net,
config=config,
train_data_loader=train_loader,
valid_data_loader=valid_loader,
test_data_loader=test_loader)
trainer.train()
## Saving model parameters
trainer.save_model_params()
## Evaluate test data
trainer.evaluate()
def main():
class Args():
def __init__(self):
pass
args = Args()
args.batch_size = 64
args.test_batch_size = 2
args.epochs = 10
args.lr = 0.0001
args.momentum = 0.5
args.no_cuda = False
args.seed = 1
args.log_interval = 100
args.save_model = True
use_cuda = not args.no_cuda and torch.cuda.is_available()
# torch.manual_seed(args.seed)
device = torch.device("cuda" if use_cuda else "cpu")
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))])
dataset_dir = Path(os.environ['HOME'])/"datasets/mnist"
train_dataset = MnistDataset(root_dir=dataset_dir/"train", transform=transform)
train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=4)
test_dataset = MnistDataset(root_dir=dataset_dir/"test", transform=transform)
test_loader = DataLoader(test_dataset, batch_size=args.test_batch_size, shuffle=True, num_workers=4)
model = LeNet().to(device)
# model = nn.DataParallel(model)
optimizer = optim.Adam(model.parameters(), lr=args.lr)
for epoch in range(1, args.epochs + 1):
train(args, model, device, train_loader, optimizer, epoch)
test(args, model, device, test_loader)
if (args.save_model):
torch.save(model.state_dict(), "mnist_cnn.pth")
def main(config):
GPUManager.auto_chooce()
engine = DefaultClassificationEngine()
engine.hooks.update(
dict(
on_sample=on_sample_hook,
on_start=on_start_hook,
on_forward=on_forward_hook,
)
)
net = LeNet(n_channels=config.n_channels, size=config.size)
print(net)
if torch.cuda.is_available():
net = net.cuda()
train_loader = torch.utils.data.DataLoader(
config.dataset(train=True),
batch_size=config.batch_size, shuffle=True, num_workers=8
)
val_loader = torch.utils.data.DataLoader(
config.dataset(train=False),
batch_size=1000, shuffle=True, num_workers=8)
optimizer = optim.SGD(net.parameters(), lr=config.lr, momentum=0.9)
recorder = defaultdict(list)
recorder.update(
dict(
dataset_name=config.dataset.__name__.split("_")[0],
lr=config.lr,
batch_size=config.batch_size
)
)
pprint(recorder)
for epoch in range(config.maxepoch):
state=engine.train(network=net, iterator=train_loader, maxepoch=1, optimizer=optimizer)
recorder["train_loss"].append(state["loss_meter"].value())
recorder["train_acc"].append(state["acc_meter"].value())
state=engine.validate(network=net, iterator=val_loader)
recorder["val_loss"].append(state["loss_meter"].value())
recorder["val_acc"].append(state["acc_meter"].value())
filename = f"{recorder['dataset_name']}_" + time.strftime("%Y%m%d_%H%M%S", time.localtime())
with open(f"../result/{filename}.static", "wb") as f:
pickle.dump(recorder, f)
def main():
transform = transforms.Compose([
transforms.Resize((32, 32)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
'ship', 'truck')
net = LeNet()
net.load_state_dict(torch.load('Lenet.pth'))
im = Image.open('1.jpg')
im = transform(im) # [C, H, W]
im = torch.unsqueeze(im, dim=0) # [N, C, H, W]
with torch.no_grad():
outputs = net(im)
predict = torch.max(outputs, dim=1)[1].data.numpy()
print(classes[int(predict)])
def usually_train():
net = LeNet() # 定义训练的网络模型
loss_function = nn.CrossEntropyLoss() # 定义损失函数为交叉熵损失函数
optimizer = optim.Adam(net.parameters(), lr=0.001) # 定义优化器（训练参数，学习率）
for epoch in range(5): # 一个epoch即对整个训练集进行一次训练
running_loss = 0.0
time_start = time.perf_counter()
for step, data in enumerate(train_loader, start=0): # 遍历训练集，step从0开始计算
inputs, labels = data # 获取训练集的图像和标签
optimizer.zero_grad() # 清除历史梯度
# forward + backward + optimize
outputs = net(inputs) # 正向传播
loss = loss_function(outputs, labels) # 计算损失
loss.backward() # 反向传播
optimizer.step() # 优化器更新参数
# 打印耗时、损失、准确率等数据
running_loss += loss.item()
if step % 1000 == 999: # print every 1000 mini-batches，每1000步打印一次
with torch.no_grad(): # 在以下步骤中（验证过程中）不用计算每个节点的损失梯度，防止内存占用
outputs = net(test_image) # 测试集传入网络（test_batch_size=10000），output维度为[10000,10]
predict_y = torch.max(outputs, dim=1)[1] # 以output中值最大位置对应的索引（标签）作为预测输出
accuracy = (predict_y == test_label).sum().item() / test_label.size(0)
print('[%d, %5d] train_loss: %.3f test_accuracy: %.3f' % # 打印epoch，step，loss，accuracy
(epoch + 1, step + 1, running_loss / 1000, accuracy))
print('%f s' % (time.perf_counter() - time_start)) # 打印耗时
running_loss = 0.0
print('Finished Training')
# 保存训练得到的参数
save_path = './Lenet.pth'
torch.save(net.state_dict(), save_path)
def model_fn(features, labels, mode, params):
"""The model_fn argument for creating an Estimator."""
model = LeNet(params["data_format"])
image = features
if isinstance(image, dict):
image = features["image"]
if mode == tf.estimator.ModeKeys.EVAL:
logits = model(image, training=False)
loss = tf.losses.sparse_softmax_cross_entropy(labels=labels,
logits=logits)
return tf.estimator.EstimatorSpec(
mode=tf.estimator.ModeKeys.EVAL,
loss=loss,
eval_metric_ops={
"accuracy":
tf.metrics.accuracy(labels=labels,
predictions=tf.argmax(logits, axis=1))
},
)
def gpu_train():
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)
# 或者
# device = torch.device("cuda")
# 或者
# device = torch.device("cpu")
net = LeNet()
net.to(device) # 将网络分配到指定的device中
loss_function = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.001)
for epoch in range(5):
running_loss = 0.0
time_start = time.perf_counter()
for step, data in enumerate(train_loader, start=0):
inputs, labels = data
optimizer.zero_grad()
outputs = net(inputs.to(device)) # 将inputs分配到指定的device中
loss = loss_function(outputs, labels.to(device)) # 将labels分配到指定的device中
loss.backward()
optimizer.step()
running_loss += loss.item()
if step % 1000 == 999:
with torch.no_grad():
outputs = net(test_image.to(device)) # 将test_image分配到指定的device中
predict_y = torch.max(outputs, dim=1)[1]
accuracy = (predict_y == test_label.to(device)).sum().item() / test_label.size(0) # 将test_label分配到指定的device中
print('[%d, %5d] train_loss: %.3f test_accuracy: %.3f' %
(epoch + 1, step + 1, running_loss / 1000, accuracy))
print('%f s' % (time.perf_counter() - time_start))
running_loss = 0.0
print('Finished Training')
save_path = './Lenet.pth'
torch.save(net.state_dict(), save_path)
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
# x_train = np.pad(x_train, ((0,0),(2,2),(2,2)), 'constant')
# x_test = np.pad(x_test, ((0,0),(2,2),(2,2)), 'constant')
# Setup network input and output
tf_x = tf.placeholder(tf.float32, (None, 1, 28, 28))
tf_y = tf.placeholder(tf.int32, (None))
one_hot_y = tf.one_hot(tf_y, 10)
# Build neural network
logits = LeNet(tf_x)
# Define loss
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=logits,
labels=one_hot_y)
loss_mean = tf.reduce_mean(cross_entropy)
# Define optimizer
initial_lr = 0.001
decay_rate = 0.6
decay_steps = 10 # 10 epoches
global_step = tf.Variable(0, trainable=False)
learning_rate = tf.train.exponential_decay(initial_lr,
global_step,
decay_steps,
decay_rate,
test_dataset = GCommandLoader(args.test_path,
window_size=args.window_size,
window_stride=args.window_stride,
window_type=args.window_type,
normalize=args.normalize)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=args.test_batch_size,
shuffle=None,
num_workers=20,
pin_memory=args.cuda,
sampler=None)
# build model
if args.arc == 'LeNet':
model = LeNet()
elif args.arc.startswith('VGG'):
model = VGG(args.arc)
else:
model = LeNet()
if args.cuda:
print('Using CUDA with {0} GPUs'.format(torch.cuda.device_count()))
model = torch.nn.DataParallel(model, device_ids=[0]).cuda()
# define optimizer
if args.optimizer.lower() == 'adam':
optimizer = optim.Adam(model.parameters(), lr=args.lr)
elif args.optimizer.lower() == 'sgd':
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
def main():
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print("using {} device.".format(device))
batch_size = 16
epochs = 200
data_transform = {
"train":
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
"val":
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
}
data_root = os.path.abspath(os.path.join(os.getcwd(),
".")) # get data root path
image_path = os.path.join(data_root, "data_set",
"flower_data") # flower data set path
assert os.path.exists(image_path), "{} path does not exist.".format(
image_path)
train_dataset = datasets.ImageFolder(root=os.path.join(
image_path, "train"),
transform=data_transform["train"])
train_num = len(train_dataset)
# {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
flower_list = train_dataset.class_to_idx
cla_dict = dict((val, key) for key, val in flower_list.items())
# write dict into json file
json_str = json.dumps(cla_dict, indent=4)
with open('class_indices.json', 'w') as json_file:
json_file.write(json_str)
nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0,
8]) # number of workers
print('Using {} dataloader workers every process'.format(nw))
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=nw)
validate_dataset = datasets.ImageFolder(root=os.path.join(
image_path, "val"),
transform=data_transform["val"])
val_num = len(validate_dataset)
validate_loader = torch.utils.data.DataLoader(validate_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=nw)
print("using {} images for training, {} images for validation.".format(
train_num, val_num))
# create model
net = LeNet(num_classes=5)
# load pretrained weights
# download url: https://download.pytorch.org/models/mobilenet_v3_large-8738ca79.pth
# download url: https://download.pytorch.org/models/mobilenet_v3_small-047dcff4.pth
# model_weight_path = "weights/LeNet_pretrained.pth"
# assert os.path.exists(model_weight_path), "file {} dose not exist.".format(model_weight_path)
# pre_weights = torch.load(model_weight_path, map_location=device)
# delete classifier weights
# pre_dict = {k: v for k, v in pre_weights.items() if net.state_dict()[k].numel() == v.numel()}
# missing_keys, unexpected_keys = net.load_state_dict(pre_dict, strict=False)
#
# # freeze features weights
# for param in net.conv_stem.parameters():
# param.requires_grad = False
#
# for param in net.bn1.parameters():
# param.requires_grad = False
#
# for param in net.act1.parameters():
# param.requires_grad = False
#
# for param in net.blocks.parameters():
# param.requires_grad = False
net.to(device)
# define loss function
loss_function = nn.CrossEntropyLoss()
# construct an optimizer
params = [p for p in net.parameters() if p.requires_grad]
optimizer = optim.Adam(params, lr=0.0001)
best_acc = 0.0
save_path = 'weights/lenet.pth'
train_steps = len(train_loader)
for epoch in range(epochs):
# train
net.train()
running_loss = 0.0
train_bar = tqdm(train_loader)
for step, data in enumerate(train_bar):
images, labels = data
optimizer.zero_grad()
logits = net(images.to(device))
loss = loss_function(logits, labels.to(device))
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(
epoch + 1, epochs, loss)
# validate
net.eval()
acc = 0.0 # accumulate accurate number / epoch
with torch.no_grad():
val_bar = tqdm(validate_loader)
for val_data in val_bar:
val_images, val_labels = val_data
outputs = net(val_images.to(device))
# loss = loss_function(outputs, test_labels)
predict_y = torch.max(outputs, dim=1)[1]
acc += torch.eq(predict_y, val_labels.to(device)).sum().item()
val_bar.desc = "valid epoch[{}/{}]".format(epoch + 1, epochs)
val_accurate = acc / val_num
print('[epoch %d] train_loss: %.3f val_accuracy: %.3f' %
(epoch + 1, running_loss / train_steps, val_accurate))
if val_accurate > best_acc:
best_acc = val_accurate
torch.save(net.state_dict(), save_path)
print('Finished Training')
def train_and_test(flags,
corruption_level=0,
gold_fraction=0.5,
get_C=uniform_mix_C):
np.random.seed(1)
torch.manual_seed(1)
torch.cuda.manual_seed(1)
C = get_C(corruption_level)
gold, silver = prepare_data(C, gold_fraction)
print("Gold shape = {}, Silver shape = {}".format(gold.images.shape,
silver.images.shape))
# TODO : test on whole set
test_x = torch.from_numpy(mnist.test.images[:500].reshape([-1, 1, 28, 28]))
test_y = torch.from_numpy(mnist.test.labels[:500]).type(torch.LongTensor)
print("Test shape = {}".format(test_x.shape))
model = LeNet()
optimizer = torch.optim.Adam([p for p in model.parameters()], lr=0.001)
for step in range(flags.num_steps):
x, y = silver.next_batch(flags.batch_size)
y, y_true = np.array([l[0] for l in y]), np.array([l[1] for l in y])
x_val, y_val = gold.next_batch(min(flags.batch_size, flags.nval))
x, y = torch.from_numpy(x.reshape(
[-1, 1, 28, 28])), torch.from_numpy(y).type(torch.LongTensor)
x_val, y_val = torch.from_numpy(x_val.reshape(
[-1, 1, 28, 28])), torch.from_numpy(y_val).type(torch.LongTensor)
# forward
if flags.method == "l2w":
ex_wts = reweight_autodiff(model, x, y, x_val, y_val)
logits, loss = model.loss(x, y, ex_wts)
if step % dbg_steps == 0:
tbrd.log_histogram("ex_wts", ex_wts, step=step)
tbrd.log_value("More_than_0.01",
sum([x > 0.01 for x in ex_wts]),
step=step)
tbrd.log_value("More_than_0.05",
sum([x > 0.05 for x in ex_wts]),
step=step)
tbrd.log_value("More_than_0.1",
sum([x > 0.1 for x in ex_wts]),
step=step)
mean_on_clean_labels = np.mean(
[ex_wts[i] for i in range(len(y)) if y[i] == y_true[i]])
mean_on_dirty_labels = np.mean(
[ex_wts[i] for i in range(len(y)) if y[i] != y_true[i]])
tbrd.log_value("mean_on_clean_labels",
mean_on_clean_labels,
step=step)
tbrd.log_value("mean_on_dirty_labels",
mean_on_dirty_labels,
step=step)
else:
logits, loss = model.loss(x, y)
print("Loss = {}".format(loss))
# backward
optimizer.zero_grad()
loss.backward()
optimizer.step()
tbrd.log_value("loss", loss, step=step)
if step % dbg_steps == 0:
model.eval()
pred = torch.max(model.forward(test_x), 1)[1]
test_acc = torch.sum(torch.eq(pred, test_y)).item() / float(
test_y.shape[0])
model.train()
print("Test acc = {}.".format(test_acc))
tbrd.log_value("test_acc", test_acc, step=step)
help='Learning rate decay',
type=float)
parser.add_argument('--batch_size', default=80, help='Batch Size', type=int)
parser.add_argument('--data_augmentation',
default=True,
help='Using data augmentation',
type=int)
parser.add_argument('--grayscale',
default=True,
help='Using data augmentation',
type=int)
parser.add_argument('--keep_prob',
default=0.8,
help='Keep probability for dropout',
type=int)
config = parser.parse_args()
trainBG = BatchGenerator(X_train, y_train, config.batch_size, config.grayscale,
'train')
validBG = BatchGenerator(X_valid, y_valid, config.batch_size, config.grayscale)
testBG = BatchGenerator(X_valid, y_valid, config.batch_size, config.grayscale)
config.decay_steps = trainBG.num_batches * config.num_epoch
label_dict = {}
with open('signnames.csv') as f:
reader = csv.DictReader(f)
for row in reader:
label_dict[row['ClassId']] = row['SignName']
#vgg = VGGsimple(config, label_dict)
#vgg.train(trainBG, validBG, config.num_epoch)
lenet = LeNet(config, label_dict)
lenet.train(trainBG, validBG, config.num_epoch)
# 定义dataloader
cifar_train = dataset.Cifar10Dataset('./cifar10/train', transform=transforms.Compose([
transforms.Resize((32, 32)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]))
cifar_test = dataset.Cifar10Dataset('./cifar10/test', transform=transforms.Compose([
transforms.Resize((32, 32)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]))
cifar_train_loader = DataLoader(cifar_train, batch_size=batch_size, shuffle=True)
cifar_test_loader = DataLoader(cifar_test, batch_size=batch_size, shuffle=False)
net = LeNet()
if MULTI_GPU:
net = nn.DataParallel(net,device_ids=device_ids)
net.to(device)
criteon = nn.CrossEntropyLoss()
optimizer=optim.Adam(net.parameters(), lr=1e-3)
scheduler = StepLR(optimizer, step_size=100, gamma=0.1)
if MULTI_GPU:
optimizer = nn.DataParallel(optimizer, device_ids=device_ids)
scheduler = nn.DataParallel(scheduler, device_ids=device_ids)
# print(net)
for epoch in range(epoch_num):
for batchidx, (label, img) in enumerate(cifar_train_loader):
net.train()
#10000张验证图片
val_set = torchvision.datasets.CIFAR10(root='./data',
train=False,
download=False,
transform=transform)
val_loader = torch.utils.data.DataLoader(val_set,
batch_size=5000,
shuffle=False,
num_workers=0)
val_data_iter = iter(val_loader)
val_image, val_label = val_data_iter.next()
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
'ship', 'truck')
net = LeNet()
loss_function = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.001)
for epoch in range(50): # loop over the dataset multiple times
running_loss = 0.0
for step, data in enumerate(train_loader, start=0):
# get the inputs; data is a list of [inputs, labels]
inputs, labels = data
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = loss_function(outputs, labels)
import numpy as np
import chainer
from chainer import cuda
import chainer.functions as F
from chainer import optimizers
from chainer import serializers
from random import randint
import cv2
from model import LeNet
point = 1
predict_num = 1
model = LeNet(predict_num)
img_size = 32
"""
if model_name == 'AlexNet':
from cnn import AlexNet
model = AlexNet(predict_num)
img_size = 227
"""
gpu = -1
if gpu >= 0:
cuda.get_device(args.gpu).use()
model.to_gpu()
xp = np if gpu < 0 else cuda.cupy
optimizer = optimizers.Adam()
optimizer.setup(model)
