def MobileNet(self):
model = models.Sequential()
from keras.applications import MobileNet
alpha = 0.75
conv_base = MobileNet(include_top=False,
weights='imagenet',
input_shape=self.input_shape,
pooling='max',
alpha=alpha)
print('MobileNet:\n')
conv_base.summary()
'''
alpha: 控制网络的宽度：
如果alpha<1，则同比例的减少每层的滤波器个数
如果alpha>1，则同比例增加每层的滤波器个数
如果alpha=1，使用默认的滤波器个数
'''
model.add(conv_base)
model.add(layers.Reshape((1, 1, int(1024 * alpha))))
model.add(layers.Dropout(0.5)) # 以前是1e-3，但是我觉得这个概率太小了，不利于泛化
model.add(
layers.Conv2D(len(self.labels), (1, 1),
padding='same',
name='conv_preds'))
model.add(layers.Activation('softmax', name='act_softmax'))
model.add(layers.Reshape((len(self.labels), ), name='reshape_2'))
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.adam(lr=2e-3),
metrics=['acc'])
return model
def make_model():
model = MobileNet(input_shape=(224, 224, 3),
alpha=1.,
weights=None,
classes=2)
model.compile(optimizer=Adam(lr=0.002),
loss='categorical_crossentropy',
metrics=[categorical_crossentropy, categorical_accuracy])
print(model.summary())
return model
def tfl_model(base_model):
if base_model == 1: # MobileNet (87 layers)
model_name = 'MobileNet'
bmodel = MobileNet(weights='imagenet', include_top=False)
elif base_model == 2: # InceptionV3 (311 layers)
model_name = 'InceptionV3'
bmodel = InceptionV3(weights='imagenet', include_top=False)
elif base_model == 3: # VGG16 (16 layers)
model_name = 'VGG16'
bmodel = VGG16(weights='imagenet', include_top=False)
elif base_model == 4: # VGG119 (22 layers)
model_name = 'VGG19'
bmodel = VGG19(weights='imagenet', include_top=False)
elif base_model == 5: # ResNet50 (175 layers)
model_name = 'ResNet50'
bmodel = ResNet50(weights='imagenet', include_top=False)
elif base_model == 6: # Xception (132 layers)
model_name = 'Xception'
bmodel = Xception(weights='imagenet', include_top=False)
elif base_model == 7: # MobileNetV2 (155 layers)
model_name = 'MobileNetV2'
bmodel = MobileNetV2(weights='imagenet', include_top=False)
#elif base_model == 8: # DenseNet121 (427 layers)
# model_name = 'DenseNet121'
# bmodel = DenseNet121(weights='imagenet',include_top=False)
#elif base_model == 9: # NASNetMobile (769 layers)
# model_name = 'NASNetMobile'
# bmodel = NASNetMobile(weights='imagenet',include_top=False)
#elif base_model == 10: # NASNetLarge (1039 layers)
# model_name = 'NASNetLarge'
# bmodel = NASNetLarge(weights='imagenet',include_top=False)
else:
print('error: base model ' + str(base_model) + ' not defined.')
bmodel.summary()
print('\nBase model ' + model_name + ' loaded with ' +
str(len(bmodel.layers)) + ' layers.')
return bmodel
def create_model(self):
from helper import precision, recall, f1_score
input = Input(shape=(dim[0], dim[1], 3), name='input')
model = MobileNet(input_shape=dim,
alpha=1,
depth_multiplier=1,
dropout=self.dropout_global,
include_top=False,
weights=self.w,
input_tensor=None)
if self.trainable:
for i in model.layers[:len(model.layers) - self.trainable]:
i.trainable = False
x = model.output
input = model.input
optimizer = SGD(learning_rate=self.eta)
else:
optimizer = Adam(lr=self.eta, amsgrad=self.amsgrad)
x = model(input)
x = GlobalAveragePooling2D()(x)
nodes = 2048
x = Dense(nodes,
activation='relu',
kernel_regularizer=l2(self.regulizer))(x)
x = Dropout(self.dropout)(x)
for i in range(self.layer_params):
nodes = int(nodes / 2)
x = Dense(nodes,
activation='relu',
kernel_regularizer=l2(self.regulizer))(x)
x = Dropout(self.dropout)(x)
z = Dense(units=self.classes, activation='softmax')(x)
model = Model(inputs=input, outputs=z)
if not self.train_mode:
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['accuracy', precision, recall, f1_score])
else:
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['accuracy'])
print(model.summary())
return model, optimizer
def build_small_mobnet(width=28, height=28, alpha=0.25, verbose=True):
dim = (height, width, 3)
input = Input(shape=dim, name='input')
model = MobileNet(input_shape=dim,
alpha=alpha,
depth_multiplier=1,
include_top=False,
weights='imagenet',
input_tensor=None)
x = model(input)
x = GlobalAveragePooling2D()(x)
x = Dense(units=512, activation='relu', kernel_regularizer=l2(0.01))(x)
x = Dropout(0.2)(x)
z = Dense(6)(x)
z = Activation('softmax')(z)
model = Model(inputs=input, outputs=z)
model.compile(loss='categorical_crossentropy',
optimizer='adadelta',
metrics=['accuracy'])
if verbose == True: print(model.summary())
return model
class_mode='binary')
test_datagen = ImageDataGenerator(rescale=1. / 255)
data_test = test_datagen.flow_from_directory("DATOS/test",
target_size=(128, 128),
class_mode='binary')
model = MobileNet(input_shape=(128, 128, 3), include_top=False, pooling='avg')
x = model.output
x = Dense(512, activation="relu")(x)
predict = Dense(1, activation="sigmoid")(x)
model = Model(inputs=model.input, outputs=predict)
adam = Adam(lr=0.0001)
model.compile(optimizer=adam, loss="binary_crossentropy", metrics=["accuracy"])
model.summary()
history = model.fit(data_train,
epochs=10,
validation_data=data_test,
verbose=1)
model.save("/Clasificador.h5")
def visualizar_img_test(path, modelo):
img = cv2.imread(path)
img_1 = cv2.resize(img, (128, 128))
img = (img_1 / 255)
img = np.expand_dims(img, axis=0)
predict = modelo.predict(img)
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
print(f"x_train.shape : {x_train.shape}")
print(f"x_test.shape : {x_test.shape}")
print(f"y_train.shape : {y_train.shape}")
print(f"y_test.shape : {y_test.shape}")
x_train = x_train.reshape(50000, 32, 32, 3).astype('float32') / 255.0
x_test = x_test.reshape(10000, 32, 32, 3).astype('float32') / 255.0
# 2. model
# vgg16 = ResNet152V2(weights='imagenet' , include_top=False, input_shape=(32,32,3))
vgg16 = MobileNet(weights='imagenet',
include_top=False,
input_shape=(32, 32, 3))
vgg16.summary()
model = Sequential()
model.add(vgg16)
model.add(Flatten())
model.add(Dense(128))
model.add(BatchNormalization())
# model.add(Dropout(0.1))
model.add(Activation('relu'))
model.add(Dense(10, activation='softmax'))
model.summary()
def Mobile_Net(trainable=None, net="MobileNet"):
# Preprocessing the dataset into keras feedable format
train_datagen = ImageDataGenerator(rotation_range=rotation,
width_shift_range=width_shift,
height_shift_range=height_shift,
rescale=scale,
shear_range=shear,
zoom_range=zoom,
horizontal_flip=horizontal,
fill_mode=fill,
validation_split=validation)
test_datagen = ImageDataGenerator(rescale=scale, )
train_generator = train_datagen.flow_from_directory(
path,
target_size=target,
batch_size=batch,
class_mode='categorical',
subset='training',
)
validation_generator = train_datagen.flow_from_directory(
path,
target_size=target,
batch_size=batch,
class_mode='categorical',
subset='validation')
models_list = ['MobileNet', 'MobileNetV2']
# Loading the MobileNet Model
if net == "MobileNet":
mobilenet = MobileNet(include_top=False,
alpha=alpha_n,
depth_multiplier=depth_multiplier_n,
dropout=dropout_num_n,
weights='imagenet',
input_shape=input_sh,
pooling=pooling_model)
if net == "MobileNetV2":
mobilenet = MobileNetV2(include_top=False,
alpha=alpha_n,
weights='imagenet',
input_shape=input_sh,
pooling=pooling_model)
if net not in models_list:
raise ValueError('Please provide the raise model ')
output = mobilenet.layers[-1].output
if pooling_model is None:
output = keras.layers.Flatten()(output)
mobilenet = Model(mobilenet.input, output=output)
print(mobilenet.summary())
print('\n\n\n')
# If you chose not for fine tuning
if trainable is None:
model = Sequential()
model.add(mobilenet)
model.add(Dense(hidden, activation='relu', input_dim=input_sh))
model.add(Dropout(dropout_num))
model.add(Dense(hidden, activation='relu'))
model.add(Dropout(dropout_num))
if classes == 1:
model.add(Dense(classes, activation='sigmoid', name='Output'))
else:
model.add(Dense(classes, activation='softmax', name='Output'))
for layer in mobilenet.layers:
layer.trainable = False
print("The model summary of Mobilenet -->\n\n\n"
) # In this the Mobilenet layers are not trainable
for i, layer in enumerate(mobilenet.layers):
print(i, layer.name, layer.trainable)
model.compile(
loss=loss_param, # Change according to data
optimizer=optimizers.RMSprop(),
metrics=['accuracy'])
print("The summary of final Model \n\n\n")
print(model.summary())
print('\n\n\n')
fit_history = model.fit_generator(
train_generator,
steps_per_epoch=len(train_generator.filenames) // batch,
epochs=epoch,
shuffle=True,
validation_data=validation_generator,
validation_steps=len(train_generator.filenames) // batch,
class_weight=n,
callbacks=[
EarlyStopping(patience=patience_param,
restore_best_weights=True),
ReduceLROnPlateau(patience=patience_param)
])
os.chdir(output_path)
model.save("model.h5")
print(fit_history.history.keys())
plt.figure(1, figsize=(15, 8))
plt.subplot(221)
plt.plot(fit_history.history['accuracy'])
plt.plot(fit_history.history['val_accuracy'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'valid'])
plt.subplot(222)
plt.plot(fit_history.history['loss'])
plt.plot(fit_history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'valid'])
plt.show()
if trainable is not None:
# Make last block of the conv_base trainable:
for layer in mobilenet.layers[:trainable]:
layer.trainable = False
for layer in mobilenet.layers[trainable:]:
layer.trainable = True
print('Last block of the conv_base is now trainable')
for i, layer in enumerate(mobilenet.layers):
print(i, layer.name, layer.trainable)
model = Sequential()
model.add(mobilenet)
model.add(Dense(hidden, activation='relu', input_dim=input_sh))
model.add(Dropout(dropout_num))
model.add(Dense(hidden, activation='relu'))
model.add(Dropout(dropout_num))
model.add(Dense(hidden, activation='relu'))
model.add(Dropout(dropout_num))
if classes == 1:
model.add(Dense(classes, activation='sigmoid', name='Output'))
else:
model.add(Dense(classes, activation='softmax', name='Output'))
for layer in mobilenet.layers:
layer.trainable = False
print("The model summary of Mobilenet -->\n\n\n"
) # In this the Mobilenet layers are not trainable
model.compile(
loss=loss_param, # Change according to data
optimizer=optimizers.RMSprop(),
metrics=['accuracy'])
print("The summary of final Model \n\n\n")
print(model.summary())
print('\n\n\n')
fit_history = model.fit_generator(
train_generator,
steps_per_epoch=len(train_generator.filenames) // batch,
epochs=epoch,
shuffle=True,
validation_data=validation_generator,
validation_steps=len(train_generator.filenames) // batch,
class_weight=n,
callbacks=[
EarlyStopping(patience=patience_param,
restore_best_weights=True),
ReduceLROnPlateau(patience=patience_param)
])
os.chdir(output_path)
model.save("model.h5")
print(fit_history.history.keys())
plt.figure(1, figsize=(15, 8))
plt.subplot(221)
plt.plot(fit_history.history['accuracy'])
plt.plot(fit_history.history['val_accuracy'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'valid'])
plt.subplot(222)
plt.plot(fit_history.history['loss'])
plt.plot(fit_history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'valid'])
plt.show()
def task2():
# Create a MobileNet model
mobile = MobileNet(weights='imagenet')
# See a summary of the layers in the model
mobile.summary()
# Modify the model
# Exclude the last 5 layers of the model
x = mobile.layers[-6].output
# Add a dropout and dense layer for predictions
x = Dropout(0.25)(x)
predictions = Dense(7, activation='softmax')(x)
# Create a new model with the new outputs
model = Model(inputs=mobile.input, outputs=predictions)
# See a summary of the new layers in the model
model.summary()
# Freeze the weights of the layers that we aren't training (training the last 23)
for layer in model.layers[:-23]:
layer.trainable = False
# Compile the model
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
# Useful variables
data_folder = '../res/Task 2/Training'
test_folder = '../res/Task 2/Test'
total_train = 8012
total_test = 2003
labels = ["AK", "BCC", "BK", "D", "MN", "M", "VL"]
batch_size = 100
epochs = 10
# this is the augmentation configuration we will use for training
train_datagen = ImageDataGenerator(
rescale=1./255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
# this is the augmentation configuration we will use for testing:
# only rescaling
test_datagen = ImageDataGenerator(rescale=1./255)
train_generator = train_datagen.flow_from_directory(
data_folder, class_mode='categorical', batch_size=batch_size, target_size=(224, 224),)
test_generator = test_datagen.flow_from_directory(
test_folder, class_mode='categorical', batch_size=batch_size, target_size=(224, 224))
# Try to deal with class imbalance: calculate class_weights so that the minority classes have a larger weight
# than the majority classes.
class_weights = class_weight.compute_class_weight(
'balanced',
np.unique(train_generator.classes),
train_generator.classes)
class_weights = dict(enumerate(class_weights))
# Train the model
model.fit_generator(
train_generator,
steps_per_epoch=total_train // batch_size,
epochs=epochs,
class_weight=class_weights
)
# Evaluate the model accuracy with the testing dataset
scores = model.evaluate_generator(test_generator, total_test // batch_size)
print("Test accuracy = ", scores[1])
# Generate predictions with the test dataset
# softmax returns a value for each class
# the predicted class for a given sample will be the one that has the maximum value
predictions = model.predict_generator(test_generator, total_test // batch_size + 1)
y_pred = np.argmax(predictions, axis=1)
# Save the predictions in a csv file
with open('results2.csv', mode="w") as results_file:
writer = csv.writer(results_file, delimiter=',',
quotechar='"', quoting=csv.QUOTE_MINIMAL)
for x in predictions:
writer.writerow(x)
# Generate confusion matrix and classification report
# Helps to evaluate metrics such as accuracy, precision, recall
print('Confusion Matrix')
cm = confusion_matrix(test_generator.classes, y_pred)
print(cm)
plot_cm(cm, labels, "second.png")
print('Classification Report')
print(classification_report(test_generator.classes, y_pred, target_names=labels))
EPOCHS = 30
size = 128
batchsize = 340
base_model = MobileNet(input_shape=(size, size, 3),
alpha=1.,
weights="imagenet",
include_top=False)
inp = base_model.input
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(NCATS, activation='softmax')(x)
model = Model(inp, x)
base_model = Sequential(model.layers[:-2])
base_model.summary()
from keras.models import Sequential
from keras.layers import BatchNormalization, Conv1D, LSTM, Dense, Dropout, Bidirectional
from keras.layers import CuDNNLSTM as LSTM # this one is about 3x faster on GPU instances
inp = Input(shape=(70, 3))
x = BatchNormalization()(inp)
# # filter count and length are taken from the script https://github.com/tensorflow/models/blob/master/tutorials/rnn/quickdraw/train_model.py
x = Conv1D(256, (5, ), activation="relu")(x)
x = Dropout(0.2)(x)
x = Conv1D(256, (5, ), activation='relu')(x)
x = Dropout(0.2)(x)
x = Conv1D(256, (3, ), activation='relu')(x)
filepath='weights_keras/{epoch:02d}-{val_loss:.2f}.hdf5',
monitor='val_acc',
save_best_only=True)
tb = TensorBoard(log_dir='./logs_keras', histogram_freq=1, batch_size=128)
from keras.applications import MobileNetV2
from keras.applications import MobileNet
k_model = MobileNet(input_shape=(224, 224, 3),
alpha=1.0,
depth_multiplier=1,
dropout=1e-3,
include_top=True,
weights=None,
input_tensor=None,
pooling=None,
classes=200)
k_model.compile(optimizer='adam',
metrics=['accuracy'],
loss='categorical_crossentropy')
k_model.summary()
k_model.fit_generator(train_generator,
validation_data=val_generator,
epochs=35,
callbacks=[ckpt],
workers=6,
use_multiprocessing=True)
from keras import Model
from keras import optimizers
from keras.preprocessing.image import ImageDataGenerator
from keras.applications import MobileNet
from keras.layers import Dense, GlobalAveragePooling2D
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelBinarizer
pickle_in = open("/content/drive/My Drive/labelfile_4.pickle", "rb")
example_dict = pickle.load(pickle_in)
y_new = example_dict
pickle_in = open('/content/drive/My Drive/trainfile_4.pickle', "rb")
X_new = pickle.load(pickle_in)
vggmodel = MobileNet(weights='imagenet', include_top=False)
vggmodel.summary()
vggmodel.trainable = False
x = vggmodel.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
x = Dense(1024, activation='relu')(x)
x = Dense(512, activation='relu')(x)
preds = Dense(3, activation='softmax')(x)
model_final = Model(input=vggmodel.input, output=preds)
from keras.optimizers import Adam
opt = Adam(lr=0.0001)
model_final.compile(loss=keras.losses.categorical_crossentropy,
# Re-loads the MobileNet model without the top or FC layers
MobileNet = MobileNet(weights='imagenet',
include_top=False,
input_shape=(img_rows, img_cols, 3))
# Here we freeze the last 4 layers
# Layers are set to trainable as True by default
for layer in MobileNet.layers:
layer.trainable = False
# Let's print our layers
for (i, layer) in enumerate(MobileNet.layers):
print(str(i) + " " + layer.__class__.__name__, layer.trainable)
print(MobileNet.summary())
def lw(bottom_model, num_classes):
"""creates the top or head of the model that will be
placed ontop of the bottom layers"""
top_model = bottom_model.output
# top_model = GlobalAveragePooling2D()(top_model)
# top_model = Dense(1024,activation='relu')(top_model)
# top_model = Dense(128, activation='relu')(top_model)
# top_model = Dense(num_classes,activation='softmax')(top_model)
top_model = Conv2D(32,
kernel_size=(3, 3),
activation='relu',
name='conv_pw_%d_bn' % block_id)(x)
return Activation(relu6, name='conv_pw_%d_relu' % block_id)(x)
if __name__ == '__main__':
print('Loading VGG16 Weights ...')
VGG16_notop = MobileNet(input_shape=None,
alpha=1.0,
depth_multiplier=1,
dropout=1e-3,
include_top=False,
weights='imagenet',
input_tensor=None,
pooling=None,
classes=1000)
VGG16_notop.summary()
print('Adding Average Pooling Layer and Softmax Output Layer ...')
output = VGG16_notop.get_layer(index=-1).output # Shape: (6, 6, 2048)
output = AveragePooling2D((8, 8), strides=(8, 8), name='avg_pool')(output)
output = Flatten(name='flatten')(output)
output = Dense(n_classes, activation='softmax', name='predictions')(output)
VGG16_model = Model(VGG16_notop.input, output)
VGG16_model.summary()
optimizer = SGD(lr=learning_rate, momentum=0.9, decay=0.001, nesterov=True)
VGG16_model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
from keras.callbacks import TensorBoard, ModelCheckpoint
from dataset import SmokeGifSequence
if __name__ == '__main__':
input_shape = (299, 299, 3)
# hdf = "m1.h5"
hdf = "temporal_vg_smoke_v1.h5"
m = MobileNet(input_shape=(299, 299, 20), weights=None, classes=2)
# load_model(hdf)
m.load_weights(hdf)
m.compile("adam", categorical_crossentropy, metrics=["accuracy"])
# plot_model(m, show_shapes=True)
m.summary()
# data_dir = "/blender/storage/datasets/smoking/gifs/"
data_dir = "/blender/storage/datasets/vg_smoke"
train_seq = SmokeGifSequence(data_dir, neg_txt='negatives.txt', pos_txt='positives.txt',
input_shape_hwc=input_shape,
only_temporal=True)
# val_seq = SmokeGifSequence(data_dir, neg_txt='validate_neg.txt', pos_txt='validate_pos.txt',
# input_shape_hwc=input_shape,
# only_temporal=True)
log_dir = os.path.join("./logs", os.path.basename(hdf))
m.fit_generator(train_seq, len(train_seq), epochs=20,
use_multiprocessing=True, workers=5,
# validation_data=val_seq, validation_steps=len(val_seq),
plt.tight_layout()
fig.savefig('gs.png', dpi=300)
plt.show();
MODEL_WEIGHTS_FILE = inDir + '/Prav_Model13.h5'
callbacks = [
ReduceLROnPlateau(monitor='val_categorical_accuracy', factor=0.5, patience=5, mode='max', cooldown=3, verbose=1),
ModelCheckpoint(MODEL_WEIGHTS_FILE, monitor='val_categorical_accuracy', save_best_only=True, verbose=1),
]
model = MobileNet(input_shape=(size, size, 1), alpha=1., weights=None, classes=NCATS)
model.compile(optimizer=Adam(lr=learning_rate), loss='categorical_crossentropy',
metrics=[categorical_crossentropy, categorical_accuracy, top_3_accuracy])
print(model.summary())
model.fit_generator(
train_datagen,
steps_per_epoch=STEPS,
# initial_epoch = initial_epoch,
epochs=EPOCHS,
verbose=1,
validation_data=(x_valid, y_valid),
callbacks = callbacks
)
model.load_weights(MODEL_WEIGHTS_FILE)
valid_predictions = model.predict(x_valid, batch_size=128, verbose=1)
history = model.fit_generator(train_generator,
epochs=100,
validation_data=validation_generator,
callbacks=model_callbacks)
test_loss, test_acc = model.evaluate_generator(test_generator)
print('test acc:', test_acc)
print('test loss:', test_loss)
#Method 3 - Fine tuning
#Builds on Method 2
#Freezing all layers up to a specific one
conv_base.trainable = True
conv_base.summary()
set_trainable = False
for layer in conv_base.layers:
if layer.name == 'conv_pw_13':
set_trainable = True
if set_trainable:
layer.trainable = True
else:
layer.trainable = False
#Fine-tuning the model - low learning rate to limit magnitude of modifications
model.compile(loss='binary_crossentropy',
optimizer=optimizers.RMSprop(lr=1e-5),
metrics=['acc'])
def convertMobileNetWeights(out_path, input_size=224, alpha=0.25, include_top=True):
if not os.path.isdir(out_path):
os.mkdir(out_path)
model_k = MobileNet(input_shape=(input_size, input_size, 3), alpha=alpha, weights='imagenet', include_top=include_top, pooling='avg')
print(model_k.summary())
model_t = MobileNet_v1(1000, alpha=alpha, input_size=input_size, include_top=include_top)
res_t = dict()
st = model_t.state_dict()
for i, el in enumerate(st):
arr = el.split('.')
print(arr)
if 'model' in el:
key = (int(arr[1]), int(arr[2]))
if key not in res_t:
res_t[key] = []
res_t[key].append((el, st[el].numpy().shape))
elif 'fc.':
key = (100, )
if key not in res_t:
res_t[key] = []
res_t[key].append((el, st[el].numpy().shape))
res_torch = dict()
for i, el in enumerate(sorted(list(res_t.keys()))):
print(i, el, res_t[el])
res_torch[i] = res_t[el]
print(res_torch[i])
total = 0
res_k = dict()
for level_id in range(len(model_k.layers)):
layer = model_k.layers[level_id]
layer_type = layer.__class__.__name__
if layer_type in ['Conv2D', 'BatchNormalization', 'DepthwiseConv2D', 'Dense']:
w = layer.get_weights()
print('{} {} {} {}'.format(total, level_id, layer_type, w[0].shape))
res_k[total] = [level_id, layer_type, w[0].shape]
# Modify state_dict
if layer_type == 'Conv2D':
weigths_t = w[0].transpose((3, 2, 1, 0))
torch_name = res_torch[total][0][0]
torch_shape = res_torch[total][0][1]
print('Modify: {}'.format(torch_name))
# Check shape
if weigths_t.shape != torch_shape:
print('Shape mismatch: {} != {}'.format(weigths_t.shape, torch_shape))
st[torch_name] = torch.from_numpy(weigths_t)
if len(res_torch[total]) == 2:
print('Store bias...')
weigths_t = w[1]
torch_name = res_torch[total][1][0]
torch_shape = res_torch[total][1][1]
print('Modify: {}'.format(torch_name))
# Check shape
if weigths_t.shape != torch_shape:
print('Shape mismatch: {} != {}'.format(weigths_t.shape, torch_shape))
st[torch_name] = torch.from_numpy(weigths_t)
elif layer_type == 'DepthwiseConv2D':
weigths_t = w[0].transpose((2, 3, 1, 0))
torch_name = res_torch[total][0][0]
torch_shape = res_torch[total][0][1]
print('Modify: {}'.format(torch_name))
# Check shape
if weigths_t.shape != torch_shape:
print('Shape mismatch: {} != {}'.format(weigths_t.shape, torch_shape))
st[torch_name] = torch.from_numpy(weigths_t)
elif layer_type == 'BatchNormalization':
for i in range(4):
weigths_t = w[i]
torch_name = res_torch[total][i][0]
torch_shape = res_torch[total][i][1]
print('Modify: {}'.format(torch_name))
# Check shape
if weigths_t.shape != torch_shape:
print('Shape mismatch: {} != {}'.format(weigths_t.shape, torch_shape))
st[torch_name] = torch.from_numpy(weigths_t)
total += 1
model_t.load_state_dict(st)
data_k = np.random.uniform(-1, 1, (100, input_size, input_size, 3)).astype(np.float32)
data_t = data_k.transpose((0, 3, 2, 1))
print(data_k.shape, data_t.shape)
pred_k = model_k.predict(data_k)
data_t = torch.from_numpy(data_t)
model_t.eval()
with torch.no_grad():
pred_t = model_t(data_t)
if include_top:
pred_t = pred_t.numpy()
else:
pred_t = pred_t.permute(0, 3, 2, 1).squeeze().numpy()
print(pred_k.shape, pred_t.shape)
diff = (pred_t - pred_k)
print(diff.min(), diff.max(), diff.mean())
if np.abs(diff).max() > 0.001:
print('Large error!')
exit()
top = '_no_top'
if include_top:
top = '_top'
torch.save(model_t.state_dict(), out_path + "mobilenet_v1_size_{}_alpha_{}{}.pth".format(input_size, alpha, top))
