def imread_scale(img_path, shape=input_shape, preprocess=input_preprocess): if preprocess: return densenet.preprocess_input( cv2.resize(imread(img_path), (shape[1], shape[0])).astype(np.float64)) else: return cv2.resize(imread(img_path), (shape[1], shape[0])).astype(np.float64)
def infer(model, image_path): img = image.load_img(image_path, target_size=(SIZE, SIZE)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) preds_with_labels = decode_predictions(preds) return dict((t[1], t[2]) for t in preds_with_labels[0])
def Main(): font = cv2.FONT_HERSHEY_SIMPLEX size = 0.5 fx = 10 fy = 10 fh = 18 ## Grab camera input cap = cv2.VideoCapture(0) # cv2.namedWindow('Original', cv2.WINDOW_NORMAL) # set rt size as 640x480 ret = cap.set(3, img_cols) ret = cap.set(4, img_rows) framecount = 0 fps = "" start = time.time() model = trainable_lyz.buildmodel() model = trainable_lyz.load_weights(model) while (True): ret, frame = cap.read() frame = cv2.flip(frame, 3) frame = cv2.resize(frame, (img_cols, img_rows)) if ret == True: framecount = framecount + 1 end = time.time() timediff = (end - start) if (timediff >= 1): fps = 'FPS:%s' % (framecount) start = time.time() framecount = 0 if framecount % 5 == 0: img = frame.astype('float32') img = densenet.preprocess_input(img) y, prob, class_name = trainable_lyz.predict( model, img, class_names) cv2.putText(frame, str(class_name) + ': ' + str(prob), (20, 20), font, 0.7, (0, 255, 0), 2, 1) cv2.imshow('video1', frame) cv2.putText(frame, fps, (10, 20), font, 0.7, (0, 255, 0), 2, 1) cv2.putText(frame, 'ESC - Exit', (fx, fy), font, size, (0, 255, 0), 1, 1) ############## Keyboard inputs ################## ## Use Esc key to close the program key = cv2.waitKey(5) & 0xff if key == 27: break #Realse & destroy cap.release() cv2.destroyAllWindows()
def loaddata(): print('loading data...') # (trainX, trainY), (testX, testY) = cifar10.load_data() trainX, trainY, testX, testY, class_names = process_img_lyz.load_js_data(path=path, img_rows=img_rows, img_cols=img_cols) # img = Image.fromarray(trainX[0]).convert('RGB') # plt.imshow(img) # plt.show() # exit(0) trainX = trainX.astype('float32') testX = testX.astype('float32') trainX = densenet.preprocess_input(trainX) testX = densenet.preprocess_input(testX) trainY = np_utils.to_categorical(trainY, nb_classes) testY = np_utils.to_categorical(testY, nb_classes) print('data loaded.') return trainX, trainY, testX, testY, class_names
def extract_DenseNet(path): import densenet from keras.preprocessing import image import numpy as np img = image.load_img(path, target_size=(224, 224)) x = image.img_to_array(img) img_tensor = densenet.preprocess_input(np.expand_dims(x, axis=0)) image_dim = (224, 224, 3) DenseNet_model = densenet.DenseNetImageNet161(input_shape=image_dim, include_top=False) DenseNet_output = DenseNet_model.predict(img_tensor) return DenseNet_output
def predict(path, model_path, index_file_path, MainUI): try: result_string = "" image_to_predict = image.load_img(path, grayscale=False, target_size=(224, 224)) image_to_predict = image.img_to_array(image_to_predict, data_format="channels_last") image_to_predict = np.expand_dims(image_to_predict, axis=0) image_to_predict = preprocess_input(image_to_predict, data_format="channels_last") if (MainUI.densenet_model_loaded == False): wx.CallAfter(pub.sendMessage, "report101", message="Loading DenseNet model for the first time. This may take few minutes or less than a minute. Please wait. \nLoading.....") model = DenseNetImageNet121(input_shape=(224, 224, 3), model_path=model_path ) wx.CallAfter(pub.sendMessage, "report101", message="DenseNet model loaded.. Picture about to be processed.. \nLoading......") MainUI.model_collection_densenet.append(model) MainUI.densenet_model_loaded = True else: wx.CallAfter(pub.sendMessage, "report101", message="Retrieving loaded model. \nLoading........") model = MainUI.model_collection_densenet[0] wx.CallAfter(pub.sendMessage, "report101", message="DenseNet model loaded.. Picture about to be processed.. \nLoading......") wx.CallAfter(pub.sendMessage, "report101", message="Picture is transformed for prediction. \nLoading........") prediction = model.predict(x=image_to_predict, steps=1) wx.CallAfter(pub.sendMessage, "report101", message="Picture prediction is done. Sending in results. \nLoading......") prediction_result = decode_predictions(prediction, top=10, index_file_path=index_file_path) for results in prediction_result: countdown = 0 for result in results: countdown += 1 result_string += "(" + str(countdown) + ") " + str(result[1]) + " : " + str(100 * result[2])[ 0:4] + "% \n" return result_string except Exception as e: return getattr(e, "message", repr(e))
growth_rate=growth_rate, nb_filter=nb_filter, dropout_rate=dropout_rate, weights=None, bottleneck=False) print("Model created") # model.summary() optimizer = Adam(lr=1e-3) # Using Adam instead of SGD to speed up training model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=["accuracy"]) print("Finished compiling") print("Building model...") (trainX, trainY), (testX, testY) = cifar10.load_data() trainX = trainX.astype('float32') testX = testX.astype('float32') trainX = densenet.preprocess_input(trainX) testX = densenet.preprocess_input(testX) Y_train = np_utils.to_categorical(trainY, nb_classes) Y_test = np_utils.to_categorical(testY, nb_classes) generator = ImageDataGenerator(rotation_range=15, width_shift_range=5. / 32, height_shift_range=5. / 32, horizontal_flip=True) # Here we zip the data and its classes so they get moved around together train = zip(trainX, trainY) # Then we sort the zipped list by its classes train = sorted(train, key=lambda x: x[1])
def train1(): batch_size = 20 nb_classes = 30 nb_epoch = 10 img_rows, img_cols = 64, 64 img_channels = 3 img_dim = (img_channels, img_rows, img_cols) if K.image_dim_ordering() == "th" else (img_rows, img_cols, img_channels) depth = 40 nb_dense_block = 3 growth_rate = 12 nb_filter = -1 dropout_rate = 0.0 # 0.0 for data augmentation model = densenet.DenseNet(img_dim, classes=nb_classes, depth=depth, nb_dense_block=nb_dense_block, growth_rate=growth_rate, nb_filter=nb_filter, dropout_rate=dropout_rate, weights=None) print("Model created") model.summary() optimizer = Adam(lr=1e-3) # Using Adam instead of SGD to speed up training model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=["accuracy"]) print("Finished compiling") print("Building model...") train_file_path = r'../DatasetA_train_20180813/train/' com_path = r'../data/com.txt' trainX, trainY, testX, testY = load_data(train_file_path, com_path) print(trainX.shape) # print(trainY.shape) print(testX.shape) # print(testY.shape) trainX = trainX.astype('float32') testX = testX.astype('float32') trainX = densenet.preprocess_input(trainX) testX = densenet.preprocess_input(testX) Y_train = np_utils.to_categorical(trainY, nb_classes) Y_test = np_utils.to_categorical(testY, nb_classes) generator = ImageDataGenerator(rotation_range=15, width_shift_range=5. / 32, height_shift_range=5. / 32, horizontal_flip=True) generator.fit(trainX, seed=0) # Load model weights_file = "weights/DenseNet-40-12-CIFAR10.h5" if os.path.exists(weights_file): # model.load_weights(weights_file, by_name=True) print("Model loaded.") out_dir = "weights/" lr_reducer = ReduceLROnPlateau(monitor='val_acc', factor=np.sqrt(0.1), cooldown=0, patience=5, min_lr=1e-5) model_checkpoint = ModelCheckpoint(weights_file, monitor="val_acc", save_best_only=True, save_weights_only=True, verbose=1) callbacks = [lr_reducer, model_checkpoint] model.fit_generator(generator.flow(trainX, Y_train, batch_size=batch_size), steps_per_epoch=len(trainX) // batch_size, epochs=nb_epoch, callbacks=callbacks, validation_data=(testX, Y_test), validation_steps=testX.shape[0] // batch_size, verbose=1) yPreds = model.predict(testX) yPred = np.argmax(yPreds, axis=1) yTrue = testY accuracy = metrics.accuracy_score(yTrue, yPred) * 100 error = 100 - accuracy print("Accuracy : ", accuracy) print("Error : ", error)
def process_data(_features, _labels): _type = 'float32' _features = densenet.preprocess_input(np.array(_features).astype(_type)) _labels = np.array(_labels).astype(_type) return _features, _labels
from __future__ import print_function from __future__ import absolute_import from keras.preprocessing import image from densenet import DenseNetImageNet121, DenseNetImageNet169, DenseNetImageNet161, preprocess_input, decode_predictions import numpy as np if __name__ == '__main__': size = 224 model = DenseNetImageNet121(input_shape=(size, size, 3)) model.summary() img_path = 'images/elephant.jpg' img = image.load_img(img_path, target_size=(size, size)) x = image.img_to_array(img) x = np.expand_dims(x, axis=0) x = preprocess_input(x) preds = model.predict(x) print('Predicted:', decode_predictions(preds))
return a[p], b[p] if __name__ == "__main__": (x_in_train, y_in_train), (x_in_test, y_in_test) = get_in_dist_train_data() (x_out_train, y_out_train), (x_out_test, y_out_test) = get_out_dist_train_data() # Concatenate in and out dist images x_train_raw = np.concatenate((x_in_train, x_out_train)) y_train_raw = np.concatenate((y_in_train, y_out_train)) x_test_raw = np.concatenate((x_in_test, x_out_test)) y_test_raw = np.concatenate((y_in_test, y_out_test)) # Pre-process inputs x_train = densenet.preprocess_input(x_train_raw) x_test = densenet.preprocess_input(x_test_raw) y_train = np_utils.to_categorical(y_train_raw, 2) y_test = np_utils.to_categorical(y_test_raw, 2) # Shuffle training data x_train, y_train = unison_shuffled_copies(x_train, y_train) x_test, y_test = unison_shuffled_copies(x_test, y_test) model = get_model() model.fit(x=x_train, y=y_train, batch_size=32, epochs=100, validation_data=(x_test, y_test))