def main():
"""Train ShallowNet on Cifar10 dataset.
"""
# load the training and testing data, then scale it into the range [0, 1]s
print("[INFO] loading CIFAR-10 data...")
((train_x, train_y), (test_x, test_y)) = cifar10.load_data()
train_x = train_x.astype("float") / 255.0
test_x = test_x.astype("float") / 255.0
# convert the labels from integers to vectors
label_binarizer = LabelBinarizer()
train_y = label_binarizer.fit_transform(train_y)
test_y = label_binarizer.transform(test_y)
# initialize the label names for the CIFAR-10 dataset
label_names = [
"airplane", "automobile", "bird", "cat", "deer", "dog", "frog",
"horse", "ship", "truck"
]
# initialize the optimizer and model
print("[INFO] compiling model...")
opt = SGD(lr=0.01)
model = ShallowNet.build(width=32, height=32, depth=3, classes=10)
model.compile(loss="categorical_crossentropy",
optimizer=opt,
metrics=["accuracy"])
# train the network
print("[INFO] training network...")
model_fit = model.fit(train_x,
train_y,
validation_data=(test_x, test_y),
batch_size=32,
epochs=40,
verbose=1)
# evaluate the network
print("[INFO] evaluating network...")
predictions = model.predict(test_x, batch_size=32)
print(
classification_report(test_y.argmax(axis=1),
predictions.argmax(axis=1),
target_names=label_names))
# plot the training loss and accuracy
plt.style.use("ggplot")
plt.figure()
plt.plot(np.arange(0, 40), model_fit.history["loss"], label="train_loss")
plt.plot(np.arange(0, 40), model_fit.history["val_loss"], label="val_loss")
plt.plot(np.arange(0, 40), model_fit.history["acc"], label="train_acc")
plt.plot(np.arange(0, 40), model_fit.history["val_acc"], label="val_acc")
plt.title("Training Loss and Accuracy")
plt.xlabel("Epoch #")
plt.ylabel("Loss/Accuracy")
plt.legend()
plt.show()
def main():
"""Train ShallowNet on animals dataset.
"""
# construct the argument parser and parse the arguments
args = argparse.ArgumentParser()
args.add_argument("-d", "--dataset", required=True, help="path to input dataset")
args = vars(args.parse_args())
# grab the list of images that we'll be describing
print("[INFO] loading images...")
image_paths = list(paths.list_images(args["dataset"]))
# initialize the image preprocessors
simple_preprocessor = SimplePreprocessor(32, 32)
image_to_array_preprocessor = ImageToArrayPreprocessor()
# load the dataset from disk then scale the raw pixel intensities to the range [0, 1]
dataset_loader = SimpleDatasetLoader(preprocessors=[simple_preprocessor, image_to_array_preprocessor])
(data, labels) = dataset_loader.load(image_paths, verbose=500)
data = data.astype("float") / 255.0
# partition the data into training and testing splits using 75% of
# the data for training and the remaining 25% for testing
(train_x, test_x, train_y, test_y) = train_test_split(data, labels, test_size=0.25, random_state=42)
# convert the labels from integers to vectors
train_y = LabelBinarizer().fit_transform(train_y)
test_y = LabelBinarizer().fit_transform(test_y)
# initialize the optimizer and model
print("[INFO] compiling model...")
opt = SGD(lr=0.005)
model = ShallowNet.build(width=32, height=32, depth=3, classes=3)
model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"])
# train the network
print("[INFO] training network...")
model_fit = model.fit(train_x, train_y, validation_data=(test_x, test_y), batch_size=32, epochs=100, verbose=1)
# evaluate the network
print("[INFO] evaluating network...")
predictions = model.predict(test_x, batch_size=32)
print(
classification_report(test_y.argmax(axis=1), predictions.argmax(axis=1), target_names=["cat", "dog", "panda"])
)
# plot the training loss and accuracy
plt.style.use("ggplot")
plt.figure()
plt.plot(np.arange(0, 100), model_fit.history["loss"], label="train_loss")
plt.plot(np.arange(0, 100), model_fit.history["val_loss"], label="val_loss")
plt.plot(np.arange(0, 100), model_fit.history["acc"], label="train_acc")
plt.plot(np.arange(0, 100), model_fit.history["val_acc"], label="val_acc")
plt.title("Training Loss and Accuracy")
plt.xlabel("Epoch #")
plt.ylabel("Loss/Accuracy")
plt.legend()
plt.show()
# 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.25,
random_state=42)
# convert the labels from integers to vectors
trainY = LabelBinarizer().fit_transform(trainY)
testY = LabelBinarizer().fit_transform(testY)
# initialize the optimizer and model
print("[INFO] compiling model...")
opt = SGD(lr=0.005)
model = ShallowNet.build(width=32, height=32, depth=3, classes=3)
model.compile(loss="categorical_crossentropy",
optimizer=opt,
metrics=["accuracy"])
# train the network
print("[INFO] training network...")
H = model.fit(trainX,
trainY,
validation_data=(testX, testY),
batch_size=32,
epochs=100,
verbose=1)
# save the network to disk
print("[INFO] serializing network...")
# partition data
trainX, testX, trainY, testY = train_test_split(data,
labels,
test_size=0.25,
random_state=42)
# Convert labels to vector
lb = LabelBinarizer()
trainY = lb.fit_transform(trainY)
testY = lb.transform(testY)
# initialize the optimizer and model
print('[INFO] compiling model...')
opt = SGD(lr=0.005)
model = ShallowNet.build(width=32,
height=32,
depth=3,
classes=len(lb.classes_))
model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['accuracy'])
# train the network
print('[INFO] training network...')
H = model.fit(trainX,
trainY,
validation_data=(testX, testY),
batch_size=32,
epochs=100,
verbose=2)
# save model to disk
# convert labels to vectors
lb = LabelBinarizer()
trainY = lb.fit_transform(trainY)
testY = lb.transform(testY)
# initialize labels names
label_names = [
'airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
'ship', 'truck'
]
# initialize optimizer and model
print('[INFO] compiling model...')
opt = SGD(lr=0.01)
model = ShallowNet.build(width=32,
height=32,
depth=3,
classes=len(label_names))
model.compile(opt, loss='categorical_crossentropy', metrics=['accuracy'])
# training network
print('[INFO] training network...')
H = model.fit(trainX,
trainY,
validation_data=(testX, testY),
batch_size=32,
epochs=40,
verbose=2)
# evaluate network
print('[INFO] evaluating network...')
preds = model.predict(testX, batch_size=32)