def test_mnist(dir_path, label_path, model_path):
# 方式１：直接加载已经训练好的模型
# model= keras.models.load_model(model_path)
# 方式２：重新构造模型，并加载训练好的权重
model = LeNet.build_lenet('subclass')
model.compile(loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.build((1,28,28,1))
model.load_weights(model_path)
# 验证准确率
test_dataset = data_loader(dir_path, label_path)
test_dataset = test_dataset.batch(10000)
test_images, test_labels = next(iter(test_dataset))
loss, acc = model.evaluate(test_images, test_labels, verbose=2)
print("Restored model, accuracy: {:5.2f}%".format(100*acc))
def train_mnist(dir_path, label_path, epochs, save_path):
"""模型训练"""
train_dataset = data_loader(dir_path, label_path)
train_dataset = train_dataset.batch(60000)
train_dataset = train_dataset.shuffle(60000)
train_dataset = train_dataset.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)
train_images, train_labels = next(iter(train_dataset))
# 定义模型——三种方式：１．sequential；2.functional API；3.自定义子类Model
model = LeNet.build_lenet('sequential')
# 2. functional API model = LeNet.build_lenet('functional')
# 3. 自定义子类Model model = LeNet.build_lenet('subclass')
# 定义优化器
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
# 模型编译
model.compile(optimizer=optimizer, loss='sparse_categorical_crossentropy', metrics=['accuracy'])
# 训练
model.fit(train_images, train_labels, epochs=epochs)
# 模型保存——两种方式：1.只存权重 2、存包含优化器和损失函数在内的整个模型(仅支持functional和sequential类型的model)
model.save(save_path)
parser.add_argument('--nb_imgs',
help='Number of picture to use in db < 10000',
type=int,
default=10000)
args = parser.parse_args()
if args.debug:
logging.basicConfig(filename='debug.log',
level=logging.INFO,
format='%(levelname)s %(asctime)s %(message)s',
filemode='w')
# dataset object creation
data = dataset(nb_imgs=args.nb_imgs)
net = LeNet()
# Dictionnary for network parameters
params = {
"conv1_weight": np.load('params/conv1.weight.save'),
"conv1_bias": np.load('params/conv1.bias.save'),
"conv2_weight": np.load('params/conv2.weight.save'),
"conv2_bias": np.load('params/conv2.bias.save'),
"dense1_weight": np.load('params/fc1.weight.save'),
"dense1_bias": np.load('params/fc1.bias.save'),
"dense2_weight": np.load('params/fc2.weight.save'),
"dense2_bias": np.load('params/fc2.bias.save'),
"dense3_weight": np.load('params/fc3.weight.save'),
"dense3_bias": np.load('params/fc3.bias.save')
}
# -*- coding:utf-8 -*-
"""
CNN手写数字识别的训练过程
训练结束后将参数保存在序列化文件中
"""
import mnist
import pickle
from network import LeNet
l = LeNet()
x_data, y_data = mnist.train_load()
x_data = x_data[:1000, :]
y_data = y_data[:1000]
learning_rate = 0.01
batch_size = 320 # 每批次的训练样本数
num_x_data = x_data.shape[0] # 总训练样本数
num_batch = num_x_data // batch_size # 每轮训练批数：1875
for t in range(1):
loss = 0
print("第%d轮训练" % (t + 1))
for i in range(num_batch):
x = x_data[i * batch_size:(i + 1) * batch_size, :]
x = x.reshape(x.shape[0], 1, 28, 28)
y = y_data[i * batch_size:(i + 1) * batch_size, :]
l.forward(x)
loss += l.backward(x, y)
for weight in [
"W1", "b1", "W2", "b2", "W3", "b3", "K1", "kb1", "K2", "kb2"
]:
l.weights[weight] -= learning_rate * l.gradients[weight]
import numpy as np
import megengine as mge
from megengine.optimizer import SGD
from megengine.autodiff import GradManager
import megengine.functional as F
from loguru import logger
from network import LeNet
from data import train_dataloader
net = LeNet()
optimizer = SGD(net.parameters(), lr=0.01, momentum=0.9, weight_decay=5e-4)
gm = GradManager().attach(net.parameters())
net.train()
total_epochs = 5
for epoch in range(total_epochs):
total_loss = 0
for step, (batch_data, batch_label) in enumerate(train_dataloader):
batch_data = mge.tensor(batch_data)
batch_label = mge.tensor(batch_label).astype(np.int32)
with gm:
pred = net(batch_data)
loss = F.loss.cross_entropy(pred, batch_label)
gm.backward(loss)
optimizer.step().clear_grad()
total_loss += loss.numpy().item()
# -*- coding:utf-8 -*-
"""
CNN手写数字识别的测试过程
模型参数保存在序列化文件中，在此读取
"""
import numpy as np
import mnist
import pickle
from network import LeNet
def get_accuracy(self, test_data, y_true):
y_pre = self.forward(test_data)
acc = np.mean(np.argmax(y_pre, axis=1) == np.argmax(y_true, axis=1))
return acc
lenet = LeNet()
x_test, y_test = mnist.test_load()
with open("model\\model_weights.pickle", "rb") as r:
lenet.weights = pickle.load(r)
acc = get_accuracy(lenet, x_test, y_test)
print("准确率为：", acc)
transforms.ToTensor(),
transforms.Normalize(
(0.1307, ),
(0.3081, )) # 数据集给出的均值和标准差系数，每个数据集都不同的，都数据集提供方给出的
])),
batch_size=batch_size,
shuffle=True)
test_loader = torch.utils.data.DataLoader( # 加载训练数据，详细用法参考我的Pytorch打怪路（一）系列-（1）
datasets.MNIST(
data_path,
train=False,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(
(0.1307, ),
(0.3081, )) # 数据集给出的均值和标准差系数，每个数据集都不同的，都数据集提供方给出的
])),
batch_size=test_batch_size,
shuffle=True)
model = LeNet() # 实例化一个网络对象
model = model.to(device)
optimizer = optim.SGD(model.parameters(), lr=lr,
momentum=momentum) # 初始化优化器
for epoch in range(1, epochs + 1): # 以epoch为单位进行循环
train(epoch)
test()
torch.save(model, model_path) # 保存模型
labels.append(label)
# scale the raw pixel intensities to the range [0, 1]
data = np.array(data, dtype="float") / 255.0
labels = np.array(labels)
# partition the data into training and testing splits using 75% of
# the data for training and the remaining 25% for testing
(trainX, testX, trainY, testY) = train_test_split(data,
labels,
test_size=0.20,
random_state=42)
# convert the labels from integers to vectors
trainY = to_categorical(trainY, num_classes=2)
testY = to_categorical(testY, num_classes=2)
model = LeNet.build(width=28, height=28, depth=3, classes=2)
opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)
model.compile(loss="binary_crossentropy", optimizer=opt, metrics=["accuracy"])
aug = ImageDataGenerator(rotation_range=30,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
fill_mode="nearest")
# train the network
print("[INFO] training network...")
H = model.fit_generator(aug.flow(trainX, trainY, batch_size=BS),
validation_data=(testX, testY),
import numpy as np
import megengine as mge
import megengine.functional as F
from data import test_dataloader
from network import LeNet
net = LeNet()
state_dict = mge.load('mnist_net.mge')
net.load_state_dict(state_dict)
net.eval()
correct = 0
total = 0
for idx, (batch_data, batch_label) in enumerate(test_dataloader):
batch_data = mge.tensor(batch_data)
batch_label = mge.tensor(batch_label).astype(np.int32)
pred = net(batch_data)
loss = F.loss.cross_entropy(pred, batch_label)
predicted = pred.numpy().argmax(axis=1)
correct += (predicted == batch_label.numpy()).sum().item()
total += batch_label.shape[0]
print("correct: {}, total: {}, accuracy: {}".format(correct, total,
float(correct) / total))
(x_train, y_train), (x_test, y_test) = datasets.cifar10.load_data()
# this is the data pre-processing
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
x_train -= np.mean(x_train)
x_test -= np.mean(x_test)
x_train /= np.std(x_train, axis=0)
x_test /= np.std(x_test, axis=0)
y_train = to_categorical(y_train, num_classes)
y_test = to_categorical(y_test, num_classes)
model = LeNet((x_train[0].shape), num_classes, 1e-3, 0.0002)
# uncomment the following for data-augmentation:
'''
aug = ImageDataGenerator(rotation_range=35, width_shift_range=0.1,
height_shift_range=0.1,zoom_range=0.3,shear_range=0.1, fill_mode="reflect")
valaug = ImageDataGenerator()
model = LeNet((xTrain[0].shape), num_classes,lr,reg)
EPOCHS = 20
H = model.fit_generator(aug.flow(xTrain, yTrain, batch_size = 8),
validation_data=valaug.flow(xTest, yTest),
epochs=EPOCHS, verbose=1)
'''