def get_video_feature(label_path, video_root_path, share_video_arr, share_video_label, share_video_sep_count): from tensorflow.python.keras.applications.resnet50 import preprocess_input _image, _label, _length = load_data(label_path, video_root_path, down_factor=12, th_count=4, video_root="data/TrimmedVideos/") print("Extract feature\n") sess = tf.Session(config=gpu_opt) K.set_session(sess) my_res = ResNet50(include_top=False, weights="model_para/resnet.h5", input_shape=[240, 320, 3]) _feature_arr = [] batch_size = 200 start = 0 for i in range(_image.shape[0] // batch_size): _feature_arr.append( my_res.predict( preprocess_input(_image[start:start + batch_size].astype("float")))) start += batch_size _feature_arr.append( my_res.predict( preprocess_input(_image[start:start + batch_size].astype("float")))) _feature_arr = np.concatenate(_feature_arr, axis=0) print("Finish extraction") sess.close() video_feature = [] video_label = [] video_sep_count = [] start = 0 for i, _l in enumerate(_length): if _l > 50: tmp = down_sample_50(_feature_arr[start:start + _l]) video_feature.append(tmp) video_label.append(_label[start]) video_sep_count.append(1) else: video_feature.append(_feature_arr[start:start + _l]) video_label.append(_label[start]) video_sep_count.append(1) start += _l print( "Concatenate each video to list.\nEach dimension is [ video , time , feature ]." ) share_video_arr["hi"] = video_feature share_video_label["hi"] = video_label share_video_sep_count["hi"] = video_sep_count
def load_model(): # load the pre-trained Keras model (you can use any some different #model or your own model here) global model model = ResNet50(weights="imagenet")
# grab the list of images that we'll be describing then randomly # shuffle them to allow for easy training and testing splits via # array sliceing during training time print("[INFO] loading images...") imagePaths = list(paths.list_images(args["dataset"])) random.shuffle(imagePaths) # extract the class labels from the image paths then encode the # labels labels = [p.split(os.path.sep)[-1].split(".")[0] for p in imagePaths] le = LabelEncoder() labels = le.fit_transform(labels) # load the ResNet50 network print("[INFO] loading network...") model = ResNet50(weights="imagenet", include_top=False) # initialize the HDF5 dataset writer, then store the class label # names in the dataset dataset = HDF5DatasetWriter((len(imagePaths), 100352), args["output"], dataKey="features", bufSize=args["buffer_size"]) dataset.storeClassLabels(le.classes_) # initialize the progress bar widgets = [ "Extracting Features: ", progressbar.Percentage(), " ", progressbar.Bar(), " ", progressbar.ETA()
class_mode='binary', target_size=(224, 224)) validation_datagen = ImageDataGenerator( preprocessing_function=preprocess_input) validation_generator = validation_datagen.flow_from_directory( 'data/validation', shuffle=False, class_mode='binary', target_size=(224, 224)) #------------------------------------------------------------------------------ # load pre-trained network, cut off its head and freeze its weights conv_base = ResNet50(include_top=False, weights='imagenet') for layer in conv_base.layers: layer.trainable = False x = conv_base.output x = layers.GlobalAveragePooling2D()(x) x = layers.Dense(128, activation='relu')(x) predictions = layers.Dense(4, activation='softmax')(x) model = Model(conv_base.input, predictions) optimizer = keras.optimizers.Adam() model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
clustering_model.layers[-1].outbound_nodes = [] clustering_model.layers[0].trainable = False # this would be the base model part #clustering_model.outputs = [clustering_model.layers[-1].output] #clustering_model.layers[-1].outbound_nodes = [] #clustering_model.layers[0].trainable = False # this would be the base model part #clustering_model.add(ResNet50(include_top = False, pooling='ave', weights = resnet_weigth_path)) #clustering_model.layers[0].trainable = False clustering_model.add(VGG16(weights= 'imagenet' ,include_top= False)) clustering_model.layers[0].trainable = False ''' clustering_model.add(ResNet50( include_top=False, pooling='ave')) #, weights = resnet_weigth_path)) clustering_model.layers[0].trainable = False elif weight_type == 'ft': num_classes = 9 base_model = ResNet50 base_model = base_model(weights='imagenet', include_top=False) x = base_model.output x = GlobalAveragePooling2D()(x) x = Dense(1024, activation='relu')(x) predictions = Dense(num_classes, activation='softmax')(x) clustering_model = Model(inputs=base_model.input, outputs=predictions) clustering_model.load_weights(fine_tuned_resnet_weight_path)
# set the mean subtraction value for each of the data augmentation objects train_datagen.mean = mean val_datagen.mean = mean ################################################################## # FINE TUNING MODEL import keras from keras.applications import ResNet50 from keras.layers import Dense, GlobalAveragePooling2D from keras.models import Model from keras.optimizers import Adam from keras.callbacks import EarlyStopping, ModelCheckpoint from keras import models, regularizers, layers, optimizers, losses, metrics conv_base = ResNet50(weights='imagenet', include_top=False, input_shape=(300, 300, 3)) model = models.Sequential() model.add(conv_base) model.add(layers.Flatten()) model.add(layers.Dropout(0.5)) model.add( layers.Dense(64, activation='relu', kernel_regularizer=regularizers.l2(0.001))) model.add(layers.Dropout(0.5)) model.add(layers.Dense(class_num, activation="softmax")) for layer in conv_base.layers[:]: layer.trainable = False
def resnet(): model = ResNet50(weights="imagenet") graph = tf.get_default_graph() return model, graph
# 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=10, shuffle=True) # Resnet initialisation with imagenet img_height, img_width = 224, 224 num_classes = 2 input_shape = (img_height, img_width, 3) #base_model=ResNet50(weights='imagenet',include_top=False,input_shape= (img_height,img_width,3)) #imports the mobilenet model and discards the restnet = ResNet50(include_top=False, weights='imagenet', input_shape=(img_height, img_width, 3)) output = restnet.layers[-1].output output = keras.layers.Flatten()(output) preds = Dense(num_classes, activation='softmax')( output) #final layer with softmax activatio model = Model(inputs=restnet.input, outputs=preds) # Freeze the layers except the last 4 layers for layer in restnet.layers[:-3]: layer.trainable = False #model.summary()
from keras.models import Model from keras.layers import Dense from keras.layers import Flatten, Dropout from keras import regularizers from keras.preprocessing.image import ImageDataGenerator from keras.applications.resnet50 import preprocess_input from keras.preprocessing.image import load_img from keras.utils.vis_utils import plot_model from keras.preprocessing.image import img_to_array from keras.applications.resnet50 import decode_predictions import keras.backend as K import numpy as np # load model without classifier layers model = ResNet50(weights="imagenet", include_top=False, input_shape=(224, 224, 3)) # add new classifier layers x = model.output x = MaxPooling2D()(x) for layer in model.layers: layer.trainable = False x = Dense(units=256, activation="relu", kernel_regularizer=regularizers.l2(0.5))(x) x = Dropout(0.4)(x) x = Dense(units=256, activation="relu", kernel_regularizer=regularizers.l2(0.5))(x) x = Dropout(0.4)(x) x = Flatten()(x)
import argparse from keras.applications import VGG16, VGG19, ResNet50, InceptionV3 ## 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__))
# In[ ]: import tensorflow # In[ ]: from keras.applications import ResNet50 # In[ ]: img_rows = 224 img_cols = 224 #Loads the ResNet50 model ResNet50 = ResNet50(weights='imagenet', include_top=True, input_shape=(img_rows, img_cols, 3)) # In[ ]: # Print Layers for (i, layer) in enumerate(ResNet50.layers): print(str(i) + " " + layer.__class__.__name__, layer.trainable) # In[ ]: from keras.applications import ResNet50 img_rows = 224 img_cols = 224
argument_parser.add_argument( '-c', '--confidence', type=float, default=0.5, help='Minimum probability to filter weak detections.') arguments = vars(argument_parser.parse_args()) INPUT_SIZE = (350, 350) PYRAMID_SCALE = 2 WINDOW_STEP = 32 ROI_SIZE = (224, 224) BATCH_SIZE = 64 print('[INFO] Loading network...') model = ResNet50(weights='imagenet', include_top=True) labels = dict() original = cv2.imread(arguments['image']) (h, w) = original.shape[:2] resized = cv2.resize(original, INPUT_SIZE, interpolation=cv2.INTER_CUBIC) batch_rois = None batch_locations = list() print('[INFO] Detecting objects...') start = time.time() for image in image_pyramid(resized, scale=PYRAMID_SCALE, min_size=ROI_SIZE):
batch_size=batch_size_training, class_mode='categorical') print('flag 1.................................................................') validation_generator = data_generator.flow_from_directory( os.path.join(cur_dir, 'concrete_data_week3/valid'), target_size=(image_resize, image_resize), batch_size=batch_size_training, class_mode='categorical') model = Sequential() model.add(ResNet50( include_top=False, pooling='avg', weights='imagenet', )) model.add(Dense(num_classes, activation='softmax')) model.layers model.layers[0].layers #Since the ResNet50 model has already been trained, then we want to tell our model not to bother with training the ResNet part, but to train only our dense output layer. To do that, we run the following. model.layers[0].trainable = False model.summary() model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
from keras import backend as K from keras.models import Model from keras.callbacks import EarlyStopping from keras.models import load_model K.set_image_dim_ordering('th') WEIGHTS_PATH = 'vgg16_weights_tf_dim_ordering_tf_kernels.h5' WEIGHTS_PATH_NO_TOP = 'resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5' img_width, img_height = 200, 200 #model = VGG16(include_top=False, weights='imagenet') input_tensor = Input(shape=(3, img_width, img_height)) # 当使用不包括top的VGG16时,要指定输入的shape,否则会报错 model = ResNet50(include_top=False, weights=None, input_tensor=input_tensor) print('Model loaded.') model.load_weights('resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5') x = model.output x = Flatten()(x) x = Dense(256, activation='relu')(x) x = Dropout(0.5)(x) x = Dense(10, activation='softmax')(x) model2 = Model(inputs=model.input, outputs=x) #model2 = load_model('mstar.h5') for layer in model2.layers[: 45]: # set the first 11 layers(fine tune conv4 and conv5 block can also further improve accuracy
def load_model(): # load the pre-trained Keras model (here we are using a model # pre-trained on ImageNet and provided by Keras, but you can # substitute in your own networks just as easily) global model model = ResNet50(weights="imagenet")
def CNN(): resnet = ResNet50(include_top=True, weights="imagenet") last = resnet.layers[-2].output model_resnet = Model(inputs=resnet.input, outputs=last) return model_resnet
# import the necessary packages import tensorflow as tf from keras.applications import ResNet50 from keras.preprocessing.image import img_to_array from keras.applications import imagenet_utils from PIL import Image import numpy as np from flask import Flask, render_template, request, redirect, flash import io # initialize our Flask application and the Keras model app = Flask(__name__) # Ensure templates are auto-reloaded app.config["TEMPLATES_AUTO_RELOAD"] = True app.secret_key = r'_5#y2L"F4Q8zsdfsdfec]/' model = ResNet50(weights="imagenet") graph = tf.get_default_graph() ALLOWED_EXTENSIONS = set(['png', 'jpg', 'jpeg']) def allowed_file(filename): return '.' in filename and \ filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS def prepare_image(image, target): # if the image mode is not RGB, convert it if image.mode != "RGB": image = image.convert("RGB")
import cv2 from keras.models import load_model import numpy as np from keras.applications import ResNet50 from keras.optimizers import Adam from keras.layers import Dense, Flatten, Input, Convolution2D, Dropout, LSTM, TimeDistributed, Embedding, Bidirectional, Activation, RepeatVector, Concatenate from keras.models import Sequential, Model from keras.utils import np_utils from keras.preprocessing import image, sequence import cv2 from keras.preprocessing.sequence import pad_sequences from tqdm import tqdm from keras.applications import ResNet50 resnet = ResNet50(include_top=False, weights='imagenet', input_shape=(224, 224, 3), pooling='avg') vocab = np.load('vocab.npy', allow_pickle=True) vocab = vocab.item() inv_vocab = {v: k for k, v in vocab.items()} embedding_size = 128 max_len = 40 vocab_size = len(vocab) image_model = Sequential() image_model.add(Dense(embedding_size, input_shape=(2048, ), activation='relu')) image_model.add(RepeatVector(max_len))
def load_model(): global model model = ResNet50(weights="imagenet") global graph graph = tf.get_default_graph()
import numpy as np import PIL.ExifTags import PIL.Image import requests from dateutil.parser import parse from keras.applications import ResNet50, imagenet_utils from keras.preprocessing.image import img_to_array from lxml import etree from pykml.factory import KML_ElementMaker as KML from textblob import TextBlob KML_POPUP_WIDTH = 400 REVERSE_GEOCODE_URL = 'https://nominatim.openstreetmap.org/reverse' SLEEP_BEFORE_REQUEST = 2 MODEL = ResNet50(weights="imagenet") OUTPUT_FILE = 'photos.kml' parser = argparse.ArgumentParser(description='Create placemarks from photos and export to KML for Google Earth.') parser.add_argument('--folder', action='store', dest='folder', help='Pick a full path to geotagged image folder.') parser.add_argument('--language', action='store', dest='language', default='en', help='Pick a language code.') locations = [] def prepare_image(image, target): if image.mode != 'RGB': image = image.convert('RGB') image = image.resize(target) image = img_to_array(image)
# initiate data augmentor for trainval set trainvalGen = HDF5DatasetGenerator( TRAINVAL_HDF5, BATCH_SIZE, # RESIZE the org image => validate/test on the whole image # substract mean, convert to keras array #preprocessors=[pp, mp, iap], #preprocessors=[pp, iap], #preprocessors=[sp, iap], preprocessors=[aap, mp, iap], classes=2, ) ## perform model surgery, load ResNet50 network without head layers, explicitly define input_tensor x = Input(shape=(224, 224, 3)) backbone = ResNet50(weights="imagenet", include_top=False, input_tensor=x) # FREEZE the backbone & train the new head layers for 10-30 epochs for layer in backbone.layers: layer.trainable = False head = backbone.output head = BatchNormalization(axis=-1)(head) head = GlobalAveragePooling2D()(head) head = Dense(NUM_CLASSES, activation="softmax")(head) model = Model(inputs=backbone.input, outputs=head) print("[INFO] plot model architecture...") arch_path = os.path.join(OUTPUT_PATH, "resnet50_new_head.png") plot_model(model, to_file=arch_path, show_shapes=True) ## initalize an optimizer & compile model & train NN
from keras.applications.vgg16 import preprocess_input, decode_predictions import prologue from mpl_toolkits.axes_grid1 import ImageGrid data_dir = r"C:\\Users\\mfajc\\Kaggle\\DogBreeds" #data_dir = r"/home/ifajcik/kaggle/dog_breed_classification/dogbreed_data" labels, _, _, _, _ = prologue.init(data_dir) NUM_CLASSES = 16 # plot image figure via ImageGrid fig = plt.figure(1, figsize=(16, 16)) j = int(np.sqrt(NUM_CLASSES)) i = int(np.ceil(NUM_CLASSES / j)) grid = ImageGrid(fig, 111, nrows_ncols=(i, j), axes_pad=0.05) #Pretrained resnet model = ResNet50(weights='imagenet') for i, (img_id, breed) in enumerate(labels.loc[labels['rank'] == 1, ['id', 'breed']].values): ax = grid[i] img = prologue.read_img(data_dir, img_id, 'train', (224, 224)) x = preprocess_input(img.copy()) ax.imshow(img / 255.) x = np.expand_dims(img, axis=0) preds = model.predict(x) _, imagenet_class_name, prob = decode_predictions(preds, top=1)[0][0] ax.text(10, 180, 'ResNet50: %s (%.2f)' % (imagenet_class_name, prob), color='w', backgroundcolor='k',
# First we need to create a model structure # input layer image_input = Input(shape=img_train.shape[1:], name="image_input") if CNN == "IV3": # Inception V3 layer with pre-trained weights from ImageNet # base_iv3_model = InceptionV3(include_top=False, weights="imagenet") base_iv3_model = InceptionV3(weights="imagenet") # Inception V3 output from input layer x = base_iv3_model(image_input) # flattening it #why? # flat_iv3 = Flatten()(output_vgg16) elif CNN == "RN50": # ResNet50 layer with pre-trained weights from ImageNet base_rn50_model = ResNet50(weights="imagenet") # ResNet50 output from input layer x = base_rn50_model(image_input) elif CNN == "Xception": # Xception layer with pre-trained weights from ImageNet base_xp_model = Xception(weights="imagenet") # Xception output from input layer x = base_xp_model(image_input) # We stack dense layers and dropout layers to avoid overfitting after that x = Dense(1000, activation="relu")(x) x = Dropout(0.2)(x) x = Dense(1000, activation="relu")(x) x = Dropout(0.2)(x) # x = Dense(240, activation="relu")(x)
import numpy as np import tensorflow as tf from PIL import Image from keras.applications.resnet50 import preprocess_input from keras.applications import ResNet50 from keras.preprocessing.image import load_img, img_to_array from keras.applications.densenet import decode_predictions model = ResNet50() graph = tf.get_default_graph() def read_and_prep_image(bytes): im = Image.open(bytes) im = im.resize((224, 224)) img_array = np.array([img_to_array(im)]) return preprocess_input(img_array) def predict(bytes): image_data = read_and_prep_image(bytes) with graph.as_default(): preds = model.predict(image_data) return decode_predictions(preds, top=1)[0]
def train(train_path, valid_path, model_save_path): os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" # 给gpu排序 os.environ["CUDA_VISIBLE_DEVICES"] = "0,1" # 选择gpu设备 if not sys.warnoptions: warnings.simplefilter("ignore") os.environ["PYTHONWARNINGS"] = "ignore" # 过滤警告提醒 config = tf.ConfigProto(device_count={ "CPU": 16}, inter_op_parallelism_threads=1, intra_op_parallelism_threads=1) # 设置CPU最大数量为16 config.gpu_options.allocator_type = 'BFC' # 使用BFC算法 BFC是分配、释放内存,碎片管理的算法 config.gpu_options.allow_growth = True # 程序按需申请内存 with tf.Session(config=config): pool = multiprocessing.Pool(processes=16) # 创建16个进程 img_datagen = ImageDataGenerator( # 图像预处理 rescale=1./255, #对图像进行放大、缩小 rotation_range=2, #随机旋转 width_shift_range=0.2, #沿着水平、垂直方向为变化范围进行平移 height_shift_range=0.2, zoom_range=[0.9, 1.2], #按比例随机缩放图像尺寸 fill_mode='nearest', #填充像素 dim_ordering='tf', pool=pool ) train_generator = img_datagen.flow_from_directory( #以文件夹路径为参数,生成经过数据提升/归一化数据,在一个无限循环中产生无限的batch数据 train_path, target_size=(299, 299), batch_size=batch_size, class_mode='categorical' ) valid_generator = img_datagen.flow_from_directory( valid_path, target_size=(299, 299), batch_size=batch_size, class_mode='categorical' ) early_stopping = EarlyStopping( #防止模型过拟合,当网络在训练集表现地越来越好,loss表现地越来越差地时候 monitor='val_acc', mode='max', min_delta=0.01, patience=8, verbose=1 ) auto_lr = ReduceLROnPlateau( #当标准评估停止提升时,降低学习速率 monitor='val_loss', factor=0.1, patience=2, verbose=1, mode='auto', eosilon=0.0001, cooldown=0, min_lr=0 ) callback_checkpoint = ModelCheckpoint(filepath=model_save_path + "{epoch:03d}" + model_name, #在每个训练期之后保存模型 monitor='val_loss', mode='min', verbose=1, save_weights_only=False, save_best_only=False) model_path = '' if os.path.exists(model_path): model = load_model(model_path) else: with tf.device("/cpu:0"): base_model = ResNet50( #加载ResNet50的Image Net的预训练模型 include_top=True, weights='imagenet', input_tensor=None, input_shape=None ) base_model = Model( #设置模型的输入与输出 inputs=[base_model.input], outputs=[base_model.get_layer('avg_pool').output], name='InceptionResNetV2' ) img = Input(shape=(299, 299, 3), name='img') feature = base_model(img) classes_count = len(os.listdir(train_path)) category_predict = Dense(classes_count, activation='softmax', name='ctg_out')( Dropout(0.5)(feature) ) model = Model(inputs=img, outputs=category_predict) #设置冻结层 for layers in base_model.layers[:20]: layers.trainable = False for layers in base_model.layers[20:]: layers.trainable = True print('---------base model layers---------','{}\t{}'.format(datetime.now().strftime('%m:%d %H-%M-%S'),len(base_model.layers)), sep='\n') print('---------train generator count---------','{}\t{}'.format(datetime.now().strftime('%m:%d %H-%M-%S'),len(train_generator.filenames)), sep='\n') optimizer = keras.optimizers.Adadelta() model.compile(optimizer=optimizer, loss = { 'ctg_out':'categorical_crossentropy' }, metrics=['accuracy']) each_epoch_callback = CustomCallback() model.fit_generator(train_generator, steps_per_epoch=len(train_generator.filenames) // (3*batch_size), epochs=epochs, verbose=1, workers=16, validation_data=valid_generator, validation_steps=len(valid_generator.filenames)//(batch_size), callbacks=[callback_checkpoint, early_stopping, auto_lr, each_epoch_callback] )
def load_model(): """load the pre-trained Keras model (here we are using a model""" global model model = ResNet50(weights="imagenet")
preprocessing_function=preproc_fn) idg_args = { 'target_size': target_size, 'color_mode': 'rgb', 'class_mode': None, 'batch_size': batch_size, 'shuffle': True } data_provider = datagen.flow_from_h5file(db_path, **idg_args) num_classes = data_provider.num_classes printmsg("Found", data_provider.tot_samples, "images belonging to", data_provider.num_classes, "classes.") # Build network if args["arch"] == 'resnet': model = ResNet50(include_top=False, weights='imagenet', input_shape=(target_size[0], target_size[1], 3), pooling='avg') elif args["arch"] == 'alexnet': model = AlexNet(include_top=False, weights='imagenet', input_shape=(3, target_size[0], target_size[1]), trainable=False) else: raise ValueError("No such architecture implemented") model.compile(optimizer='rmsprop', loss='mse') n_logits = model.output_shape[1] printmsg("Network created -", n_logits, "logits") # Start writing the databases with h5py.File(filename, read_mode) as f: printmsg("Output file", filename, "opened")
def load_model(): global model model = ResNet50(weights="imagenet")
from sklearn.metrics import confusion_matrix import itertools %matplotlib inline from tensorflow.python.keras.preprocessing import image from tensorflow.python.keras.applications.inception_v3 import * import numpy as np from keras.applications import ResNet50 train_path = 'Path_for_Images' test_path = 'Path_for_Images' train_batches = ImageDataGenerator().flow_from_directory(train_path,target_size=(197,197),classes=['positive','negative'],batch_size=1) test_batches = ImageDataGenerator().flow_from_directory(test_path,target_size=(197,197),classes=['positive','negative'],batch_size=1) images, train_labels = next(train_batches) resnet_model = ResNet50(include_top=True,weights='imagenet') resnet_model = keras.applications.resnet50.ResNet50(weights=None,classes=2,input_shape=(197,197,3)) resnet_model.summary() for layer in resnet_model.layers: layer.trainable = False resnet_model.compile(Adam(lr=0.0001),loss='categorical_crossentropy',metrics=['accuracy']) resnet_model.fit_generator(train_batches,epochs=5) test_images, test_labels = next(test_batches) predict = resnet_model.predict_generator(test_batches) test_batches = ImageDataGenerator().flow_from_directory(test_path,target_size=(197,197),classes=['positive','negative'],batch_size=564) test_images, test_labels = next(test_batches) counter = 0
from keras.models import Sequential from keras.layers import Dense, Conv2D, Activation, Flatten, MaxPool2D, BatchNormalization from keras.optimizers import Adam from keras.applications import ResNet50 from keras.applications import resnet50 as resnet50 from keras.preprocessing import image #%% # new_model = ResNet50( # include_top = False, # weights = 'imagenet', # intput_shape = [32,32,3] # ) new_model = ResNet50() #%% # if we need to resize the image: import skimage.transform # for each image: # new_image = skimage.transform.resize(image, (299, 299), mode='constant') # X_train_reshape.append(new_image) new_image = skimage.transform.resize(train_images[6], (224, 224), mode='constant') plt.hist(new_image.flatten()) np.max(new_image.flatten()) np.min(new_image.flatten())