示例#1
0
# 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...")
from keras.models import load_model

import matplotlib.pyplot as plt
import numpy as np

from shallownet import ShallowNet

(X_train, y_train), (X_test, y_test) = cifar10.load_data()
X_train = X_train.astype('float')/255
X_test = X_test.astype('float')/255

lb = LabelBinarizer()
y_train = lb.fit_transform(y_train)
y_test = lb.transform(y_test)

model = ShallowNet.build(32, 32, 3, 10)
sgd = SGD()
model.compile(sgd, 'categorical_crossentropy', ['accuracy'])
H = model.fit(X_train, y_train, 64, 30, validation_data=(X_test, y_test))

#save and load model
model.save('./model/shallow_weight.hdf5')
model = load_model('./model/shallow_weight.hdf5')
# model.predict....

# graph of loss and accuracy
fig = plt.figure()
plt.plot(np.arange(0, 30), H.history['loss'], label='training loss')
plt.plot(np.arange(0, 30), H.history['val_loss'], label='validation loss')
plt.plot(np.arange(0, 30), H.history['acc'], label='accuracy')
plt.plot(np.arange(0, 30), H.history['val_acc'], label='validation accuracy')
((X_train, y_train), (X_test, y_test)) = cifar10.load_data()
X_train = X_train.astype("float") / 255.0
X_test = X_test.astype("float") / 255.0

lb = LabelBinarizer()
y_train = lb.fit_transform(y_train)
y_test = lb.transform(y_test)

labelNames = [
    "airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse",
    "ship", "truck"
]

print("[INFO] compiling model...")
opt = SGD(lr=0.01)
model = ShallowNet.build(height=32, width=32, depth=3, classes=10)
model.compile(loss="categorical_crossentropy",
              optimizer=opt,
              metrics=["accuracy"])

print("[INFO] training network...")
H = model.fit(X_train,
              y_train,
              validation_data=(X_test, y_test),
              batch_size=32,
              epochs=40,
              verbose=1)

print("[INFO] evaluating network...")
predictions = model.predict(X_test, batch_size=32)
print(
示例#4
0
## construct arguments
parser = argparse.ArgumentParser()
parser.add_argument("-i", "--include_top", type=int, default=1, \
        help="1/-1 indicates whether to include the head of neural network or not")
parser.add_argument("-m", "--model", type=str, default="vgg16", \
        help="which model model to inspect")
args = vars(parser.parse_args())

networkBanks = {
        "vgg16" : VGG16(weights="imagenet", include_top=args["include_top"] > 0),
        "vgg19" : VGG19(weights="imagenet", include_top=args["include_top"] > 0),
        "resnet50" : ResNet50(weights="imagenet", \
                include_top=args["include_top"] > 0),
        "inceptionv3" : InceptionV3(weights="imagenet", \
                include_top=args["include_top"] > 0),
        "shallownet" : ShallowNet.build(height=28, width=28, depth=3, classes=10),
        "lenet" : LeNet.build(height=28, width=28, depth=3, classes=10),
        "minivgg" : MiniVGGNet.build(height=28, width=28, depth=3, classes=10),
        #"kfer_lenet" : KFER_LeNet.build(height=48, width=48, depth=3, classes=7),
        }

## loading network
print("[INFO] loading network =", args["model"])
model = networkBanks[args["model"]]

# inspect layers
for i, layer in enumerate(model.layers):
    print("[INFO] {}\t{}".format(i, layer.__class__.__name__))