def predict_video(model_class):
cap = cv2.VideoCapture(0)
while True:
ret, frame = cap.read()
height, width, _ = frame.shape
if type(model_class) == BasicModel:
frame_resized = cv2.resize(frame, (224, 224))
frame_preprocessed = preprocess_input(frame_resized).reshape(
1, 224, 224, 3)
else:
frame_preprocessed = preprocess_input(frame).reshape(
1, height, width, 3)
x_scaled, y_scaled = model_class.predict(frame_preprocessed)[0]
x = int(x_scaled * width)
y = int(y_scaled * height)
cv2.circle(frame, (x, y), 5, (0, 0, 255), -1)
cv2.imshow('frame', frame)
k = cv2.waitKey(30) & 0xff
if k == 27: # press 'ESC' to quit
break
cap.release()
cv2.destroyAllWindows()
def get_preprocessing_func(model_name):
if model_name == 'resnet_50_v2':
from tensorflow.keras.applications.resnet_v2 import preprocess_input
elif model_name == 'vgg16':
from tensorflow.keras.applications.vgg16 import preprocess_input
preprocess_input(tf.zeros([4, 32, 32, 3]))
return lambda x, y: (preprocess_input(x), y)
def define_model() -> Tuple[Model, Model]:
"""Defines the architecture of the model."""
i = Input([None, None, 3], dtype=tf.uint8)
x = tf.cast(i, tf.float32)
x = preprocess_input(x)
# base_model = MobileNetV2(include_top=False, weights='imagenet', input_shape=(192, 192, 3))
# base_model = ResNet50(include_top=False, weights='imagenet', input_shape=(192, 192, 3))
base_model = ResNet152V2(include_top=False,
weights='imagenet',
input_shape=(192, 192, 3))
x = base_model(x)
x = GlobalAveragePooling2D()(x)
x = Dense(512, kernel_regularizer='l2')(x)
x = BatchNormalization()(x)
x = ReLU()(x)
# x = LayerNormalization()(x)
# x = Dense(256, kernel_regularizer='l2')(x)
# x = BatchNormalization()(x)
# x = ReLU()(x)
# x = LayerNormalization()(x)
x = Dense(64, kernel_regularizer='l2')(x)
x = BatchNormalization()(x)
x = ReLU()(x)
# x = LayerNormalization()(x)
predictions = Dense(1, activation='sigmoid', kernel_regularizer='l2')(x)
model = Model(inputs=[i], outputs=predictions)
return model, base_model
def train(images, labels):
model = prepare_model()
checkpoint = ModelCheckpoint('models/model_task_3_2.h5', monitor='val_loss', verbose=1, mode='min', save_best_only=True)
reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=2, min_lr=0.001)
callbacks_list = [checkpoint, reduce_lr]
images = preprocess_input(images)
def encode_ordinal(class_val):
return [
1 if class_val > 1 else 0,
1 if class_val > 2 else 0,
1 if class_val > 3 else 0
]
labels = np.array(list(map(encode_ordinal, labels)))
# Shuffle
randomize = np.arange(len(images))
np.random.shuffle(randomize)
images = images[randomize]
labels = labels[randomize]
model.fit(x=images, y=labels, epochs=15, batch_size=64, validation_split=0.3, shuffle=False, callbacks=callbacks_list)
# model.save('adiz_trained.h5')
labels = model.predict(images)
scores = model.evaluate(images, labels, verbose=0)
print("%s: %.2f%%" % (model.metrics_names[1], scores[1]))
def detect_and_predict_mask(frame, faceNet, maskNet):
(h, w) = frame.shape[:2]
blob = cv2.dnn.blobFromImage(frame, 1.0, (800, 800), (104.0, 177.0, 123.0))
faceNet.setInput(blob)
detections = faceNet.forward()
faces = []
locs = []
preds = []
for i in range(0, detections.shape[2]):
confidence = detections[0, 0, i, 2]
if confidence > args.confidence:
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")
(startX, startY) = (max(0, startX), max(0, startY))
(endX, endY) = (min(w - 1, endX), min(h - 1, endY))
face = frame[startY:endY, startX:endX]
face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
face = cv2.resize(face, (224, 224))
face = img_to_array(face)
face = preprocess_input(face)
faces.append(face)
locs.append((startX, startY, endX, endY))
if len(faces) > 0:
faces = np.array(faces, dtype="float32")
preds = maskNet.predict(faces, batch_size=32)
return (locs, preds)
def preprocess(image):
image = tf.io.decode_png(tf.io.read_file(image), channels=3)
image = tf.image.resize_with_pad(image=image,
target_height=HEIGHT,
target_width=WIDTH)
image = resnet_v2.preprocess_input(image)
return image
def build_model(classes=2):
inputs = Input(shape=(IMAGE_SIZE, IMAGE_SIZE, 3))
x = preprocess_input(inputs)
x = ResNet152V2(weights=None, classes=classes)(x)
model = Model(inputs=inputs, outputs=x)
model.compile(loss='categorical_crossentropy', metrics=['accuracy'])
return model
def generate_integrated_grad(input_image):
arr = np.array(input_image)
image = preprocess_input(cv2.resize(arr, (224, 224)))
race = encode_image(integrated_grad_PIL(image, "race"))
gender = encode_image(integrated_grad_PIL(image, "gender"))
age = encode_image(integrated_grad_PIL(image, "age"))
return race, gender, age
def predict(input_image):
arr = np.array(input_image)
# print(preprocess_input(arr), file=sys.stderr)
image = preprocess_input(cv2.resize(arr,
(224, 224))).reshape(-1, 224, 224, 3)
# Race
race_dict = {
0: 'Black',
1: 'East Asian',
2: 'Latino/Hispanic',
3: 'Indian',
4: 'Middle Eastern',
5: 'SE Asian',
6: 'White'
}
race_model = load_model('models/race_v6.hdf5')
race_pred = race_model.predict(image)
race = race_dict[np.argmax(race_pred)]
race_percent = list(map(lambda x: round(x * 100), race_pred[0]))
race_results = []
for i in range(len(race_percent)):
race_results.append({"cat": race_dict[i], "val": race_percent[i]})
# Gender
gender_dict = {0: "Female", 1: "Male"}
gender_model = load_model('models/gender_v1.hdf5')
gender_pred = gender_model.predict(image)
gender = gender_dict[np.argmax(gender_pred)]
gender_percent = list(map(lambda x: round(x * 100), gender_pred[0]))
gender_results = []
for i in range(len(gender_percent)):
gender_results.append({
"cat": gender_dict[i],
"val": gender_percent[i]
})
# Age
age_dict = {
0: "0-2",
1: "10-19",
2: "20-29",
3: "3-9",
4: "30-39",
5: "40-49",
6: "50-59",
7: "60-69",
8: "more than 70"
}
age_model = load_model('models/age_v1.hdf5')
age_pred = age_model.predict(image)
age = age_dict[np.argmax(age_pred)]
age_percent = list(map(lambda x: round(x * 100), age_pred[0]))
age_results = []
for i in range(len(age_percent)):
age_results.append({"cat": age_dict[i], "val": age_percent[i]})
return race, gender, age, race_results, gender_results, age_results
def preprocess(im):
#im = img_to_array(load_img(os.path.join(SAMPLE_DIR,filename),target_size = TARGET_SIZE))
x = keras_image.img_to_array(im)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
return x
def get_data_loader(data : tuple, data_subset_mode='train', batch_size=32, num_classes=None, infinite=True, augment=True, seed=2836):
num_samples = len(data[0])
x = tf.data.Dataset.from_tensor_slices(data[0])
labels = tf.data.Dataset.from_tensor_slices(data[1])
data = tf.data.Dataset.zip((x, labels))
data = data.cache()
if data_subset_mode == 'train':
data = data.shuffle(buffer_size=num_samples)
# data = data.map(lambda x,y: (tf.image.convert_image_dtype(load_img(x)*255.0,dtype=tf.uint8),y), num_parallel_calls=-1)
# data = data.map(load_example, num_parallel_calls=AUTOTUNE)
data = data.map(load_example, num_parallel_calls=AUTOTUNE)
data = data.map(lambda x,y: (preprocess_input(x), y), num_parallel_calls=AUTOTUNE)
if infinite:
data = data.repeat()
if data_subset_mode == 'train':
data = data.shuffle(buffer_size=200, seed=seed)
augmentor = TRAIN_image_augmentor
elif data_subset_mode == 'val':
augmentor = VAL_image_augmentor
elif data_subset_mode == 'test':
augmentor = TEST_image_augmentor
if augment:
data = augmentor.apply_augmentations(data)
data = data.batch(batch_size, drop_remainder=True)
return data.prefetch(AUTOTUNE)
def predict(self):
# load weights
resnet_model.load_weights(self.weights)
# in case of rbg image
if self.rgb:
image = plt.imread(self.image)
x = cv2.resize(image, (224, 224))
# in case of brg image
else:
x = cv2.cvtColor(self.image, cv2.COLOR_BGR2RGB)
# preprocess image for resnet model
p_image = preprocess_input(x)
# add batch
input_image = p_image[None, ...]
# predict emotion
predict = resnet_model.predict_classes(input_image)
# list of emotion in alphabetical order
emo = [
'anger', 'contempt', 'disgust', 'fear', 'happy', 'neutral', 'sad',
'surprise', 'uncertain'
]
return emo[int(predict)]
def prepare_image(image):
if image.mode != 'RGB':
image = image.convert("RGB")
image = image.resize((224, 224))
image_tensor = img_to_array(image)
preprocessed_img = preprocess_input(image_tensor)
preprocessed_img = np.expand_dims(preprocessed_img, axis=0)
return preprocessed_img
def simple_decode(img):
img = tf.image.decode_jpeg(img, channels=3)
#img = tf.image.convert_image_dtype(img, tf.float32) # NOTE: Must do this before other operations or can mangle img
# TODO the above was causing issues? I don't understand anymore...
# TODO I know it should cause issues with mixed precision but why was it handicaping performance?
img = tf.image.resize(img, [settings.IMG_WIDTH, settings.IMG_HEIGHT])
img = preprocess_input(img) # NOTE: This does A TON for accuracy
#img = tf.image.convert_image_dtype(img, tf.float32) #TODO remove this if preproces sis used
return img
def get_preprocessing_func(model_name):
if model_name.startswith('resnet'):
from tensorflow.keras.applications.resnet_v2 import preprocess_input
elif model_name == 'vgg16':
from tensorflow.keras.applications.vgg16 import preprocess_input
elif model_name == 'shallow':
def preprocess_input(x):
return ((x/255.0)-0.5)*2.0
return lambda x, y: (preprocess_input(x),y)
def prep(img):
if deb: print('check uint8:', img[0][0, :10, :2])
print(img.shape)
img = crop_center_square(img)
print(img.shape)
img = tf.image.resize(img, (224, 224)) # img[:,:,20:300]
print(img.shape)
img = preprocess_input(img)
if deb: print('after preprocess: ', img[0][0, :10])
#print('np' ,img.shape)
return img
def format_image(self, image):
"""Resize the images to a fixed input size, and
rescale the input channels to a range of [-1, 1].
(According to https://www.tensorflow.org/tutorials/images/transfer_learning)
"""
image = tf.cast(image, tf.float32)
# \/ does the same # image = (image / 127.5) - 1
image = preprocess_input(
image
) # https://github.com/keras-team/keras-applications/blob/master/keras_applications/imagenet_utils.py#L152
image = tf.image.resize(image, (self.IMG_SIZE, self.IMG_SIZE))
return image
def do(images):
images = resnet_v2.preprocess_input(np.asarray(images))
model = self.resnet(include_top=False,
weights='imagenet',
input_tensor=None,
input_shape=images[0].shape,
pooling=None,
classes=None, # ignored when include_top False
classifier_activation=None, # ignored when include_top False
)
feature_maps = model.predict(images)
tf.keras.backend.clear_session()
return images
def map_decode_fn(images):
images = tf.io.decode_jpeg(images)
images = tf.image.resize(images,
(MLConfig.INPUT_WIDTH, MLConfig.INPUT_HEIGHT),
method="nearest")
images.set_shape((MLConfig.INPUT_WIDTH, MLConfig.INPUT_HEIGHT, 3))
images = tf.cast(images, tf.float32)
if MLConfig.BACKBONE == "resnet":
images = resnet_v2.preprocess_input(images)
elif MLConfig.BACKBONE == "efficientnet":
images = efficientnet.preprocess_input(images)
else:
raise ValueError()
return tf.cast(images, tf.float32)
def decode_img(img):
# convert the compressed string to a 3D uint8 tensor
# img = tf.image.decode_jpeg(img)
img = tf.image.decode_jpeg(img, channels=3)
#img = tf.image.convert_image_dtype(img, tf.float32)
img = tf.image.resize(img, [settings.IMG_WIDTH, settings.IMG_HEIGHT])
# img = tf.image.decode_image(img)
# img = tf.image.decode_jpeg(img)
# img = tf.image.decode_image(img, channels=0)
# img = tf.image.decode_jpeg(img, channels=0)
# img = tf.image.resize(img, [IMG_WIDTH*2, IMG_HEIGHT*2])
# img = zoom(img)
# st.write(img)
# img = tf.image.convert_image_dtype(img, tf.float32)
#NUM_BOXES = 3
#boxes = tf.random.uniform(shape=(NUM_BOXES, 3))
#box_indices = tf.random.uniform(shape=(NUM_BOXES,), minval=0, maxval=settings.BATCH_SIZE, dtype=tf.int32)
#img = tf.image.crop_and_resize(img, boxes, box_indices, (settings.IMG_HEIGHT, settings.IMG_WIDTH))
# st.write(img)
# Use `convert_image_dtype` to convert to floats in the [0,1] range.
# resize the image to the desired size.
# img = tf.image.random_crop(img, [IMG_WIDTH, IMG_HEIGHT, 3])
img = tf.image.random_flip_left_right(img)
img = tf.image.random_flip_up_down(img)
img = tf.image.rot90(
img, tf.random.uniform(shape=[], minval=0, maxval=4, dtype=tf.int32))
# TODO test if this is corrupting jpg
img = tf.image.random_hue(img, 0.02)
#img = tf.image.random_saturation(img, 0.6, 1.6)
img = tf.image.random_brightness(img, 0.02)
img = tf.image.random_contrast(img, 0.02, 0.05)
# img = tf.image.convert_image_dtype(img, tf.float16)
# img = tf.image.resize(img, [IMG_WIDTH, IMG_HEIGHT])
img = preprocess_input(img) # This handles float conversion
# img = tf.image.resize(img, [settings.IMG_WIDTH, settings.IMG_HEIGHT])
#img = tf.image.convert_image_dtype(img, tf.float32) #TODO remove this if preproces sis used
# st.write(img)
return img
def __getitem__(self, index):
'Generate one batch of data'
# selects indices of data for next batch
indexes = self.indexes[index * self.batch_size:(index + 1) *
self.batch_size]
# select data and load images
y = np.array([self.y[k] for k in indexes])
X = [
np.array(image.load_img(self.X[k], target_size=self.dim))
for k in indexes
]
if self.augmentor != None:
X = self.augmentor(X)
X = np.array([preprocess_input(x) for x in X])
return X, y
def get_image(filename: str, size: tuple = (212, 320)):
"""
Function to load image as tensor and resize it to specific size
Args:
filename: file name (path)
size: tuple (height, width) with size of image after resizing
Returns:
Image as tf.Tensor
"""
image = tf.io.read_file(filename)
image = tf.image.decode_jpeg(image)
# Use cast instead of convert_image_dtype to avoid rescaling
image = tf.cast(image, tf.float32)
image = tf.image.resize_with_crop_or_pad(image,
target_height=size[0],
target_width=size[1])
image = preprocess_input(image)
return image
def EncoderPretrained(config, inputs):
if not 'kp_backbone' in config:
config['kp_backbone'] = 'resnet'
if config['kp_backbone'] == "resnet":
from tensorflow.keras.applications.resnet_v2 import preprocess_input
elif "efficientnet" in config['kp_backbone']:
from tensorflow.keras.applications.efficientnet import preprocess_input
if config['kp_backbone'] == "resnet":
net = tf.keras.applications.ResNet152V2
elif config['kp_backbone'] == 'efficientnet':
net = tf.keras.applications.EfficientNetB7
inputss = preprocess_input(inputs)
net = net(input_tensor=inputss,
include_top=False,
weights='imagenet',
pooling='avg')
for i, layer in enumerate(net.layers):
#print('layer',layer.name,i,layer.output.shape)
layer.trainable = False
if config['kp_backbone'] == "resnet":
layer_name = [
'conv3_block8_1_relu', "conv3_block8_preact_relu",
"max_pooling2d_1"
][1] # 32x32
layer_name = 'conv2_block3_1_relu' # 64x64x64
elif config['kp_backbone'] == "efficientnet":
layer_name = ['conv3_block8_1_relu'][0]
feature_activation = net.get_layer(layer_name)
model = tf.keras.models.Model(name="ImageNet Encoder",
inputs=net.input,
outputs=[feature_activation.output])
return model
def tag_file(file_name):
"""
This method classifies one given image.
:param file_name: Path to the file, that should be classified.
:return: Tags as list of strings
"""
f = open('labels.txt', 'w+')
res = []
if file_name.endswith('.jpeg') or file_name.endswith('.jpg'):
# preprocess an image
img = tf_image.load_img(file_name,
target_size=Tagger.input_image_size[:2])
img = tf_image.img_to_array(img)
img = np.expand_dims(img, axis=0)
img = preprocess_input(img)
# apply NN and make a prediction
predictions = Tagger.model.predict(img)
# decode the results into a list of tuples (class, description, probability)
# (one such list for each sample in the batch)
translated_predictions = decode_predictions(predictions, top=2)[0]
if float(translated_predictions[0][2]) - float(
translated_predictions[1][2]) <= 0.08:
res = [
translated_predictions[0][1], translated_predictions[1][1]
]
tf.keras.backend.print_tensor(Tagger.model.layers[-1].output)
else:
res = [translated_predictions[0][1]]
f.close()
return res
import matplotlib.pyplot as plt
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.applications import InceptionV3
import time
# Import train data
train_imagePaths = glob.glob('data/data/train/*/*')
train_labels = []
train_images = []
print("=> Loading Training images")
for i,imagePath in enumerate(train_imagePaths):
train_labels.append(imagePath.split('/')[-2])
image = cv2.imread(imagePath)
# image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
image = cv2.resize(image, (224, 224))
image = preprocess_input(image)
# image = np.repeat(image[..., np.newaxis], 3, -1)
train_images.append(image)
train_images = np.array(train_images)
train_labels = np.array(train_labels)
print("=> Loaded {} train images".format(train_images.shape[0]))
lb = LabelBinarizer()
train_labels = lb.fit_transform(train_labels)
# Import validation data
val_imagePaths = glob.glob('data/data/val/*/*')
val_labels = []
val_images = []
print("=> Loading Validation images")
for i,imagePath in enumerate(val_imagePaths):
def augment_dataset(project_id):
config = model.get_config(project_id)
config['input_image_shape'] = cv.imread(glob(os.path.join(config['data_dir'],'train/*.png'))[0]).shape[:2]
h = config['input_image_shape'][0]
w = config['input_image_shape'][1] // (2+ len(config['keypoint_names'])//3)
print(config)
print(h,w, 4 * w)
file_list, dataset_train = model.load_raw_dataset(config,'train')
inputs = tf.keras.layers.Input(shape=[config['img_height'], config['img_width'], 3])
inputss = preprocess_input(inputs)
net = tf.keras.applications.ResNet152V2(input_tensor=inputss,
include_top=False,
weights='imagenet',
pooling='avg')
net.summary()
if 0:
for layer in net.layers:
try:
print(layer.name,layer.outputs[0].shape)
except:
pass
layer_name = 'conv1_conv'
feature_activation = net.get_layer(layer_name)
feature_extractor = tf.keras.models.Model(name="ImageNet Encoder",inputs=net.input,outputs=[feature_activation.output])
output_dir = '/tmp/feature_augment'
if not os.path.isdir(output_dir):
os.makedirs(output_dir)
files = [f for f in sorted(glob(os.path.join(config['data_dir'],'train/*.png'))) if not 'augment-' in f]
for i,f in enumerate(files):
im = cv.imread(f)
rgb = im[:,:w,:]
rgb = rgb.reshape((1,) + rgb.shape)
rgb = preprocess_input(rgb)
features = feature_extractor(rgb,training=False).numpy()[0,:,:,:]
features = cv.resize(features,None,None,fx=2.,fy=2.)
print('[*] wrote %i/%i:'%(i,len(files)),im.shape,features.shape,features.min(),features.max())
for j in range(2):
fo = os.path.join(config['data_dir'],'train/augment-%i-%i.png' % (i,j) )
#print(fo)
a = np.zeros_like(features[:,:,0])
b = np.zeros_like(features[:,:,0])
c = np.zeros_like(features[:,:,0])
for k in range(features.shape[-1] // 3):
a += features[:,:,int(np.random.uniform(features.shape[-1]))]
b += features[:,:,int(np.random.uniform(features.shape[-1]))]
c += features[:,:,int(np.random.uniform(features.shape[-1]))]
abc = cv.merge((a,b,c))
thresh = 1.
abc[thresh > np.abs(abc)] = thresh
abc8 = 255. * (abc-abc.min())/(1e-5+abc.max()-abc.min())
abc8 = np.uint8(abc8)
abc8 = np.hstack((abc8,im[:,w:,:]))
cv.imwrite(fo,abc8)
'''for x,y in dataset_train:
def grad_cam():
# Read input
req_data = request.get_json()
# Label contains filename (not full path)
label = req_data['label']
# img (preprocessed?)
img = req_data['image']
# Get label index
label = label.split('_')[0] + '_' + label.split('_')[1]
label_idx = np.where(np.array(model.classes)[:, 0] == label)[0][0]
# # Load and prepare (normalize) image
img = image.img_to_array(img)
img = tf.image.resize_with_crop_or_pad(img, 224, 224)
img_to_plot = img / 255.0
img = preprocess_input(img)
img = img.numpy()
# Reshape image to (batch_size, heigh, width, channel)
img = img.reshape(-1, *img.shape)
# Gradient model, outputs tuple with:
# - output of conv layer
# - output of head layer
grad_model = tf.keras.models.Model(
[model.model.inputs],
[model.model.get_layer('conv5_block3_3_conv').output, model.model.output])
# Run model and record outputs, loss, and gradients
with tf.GradientTape() as tape:
conv_outputs, predictions = grad_model(img)
loss = predictions[:, label_idx]
# Output of conv layer
output = conv_outputs[0]
# Gradients of loss wrt. conv layer
grads = tape.gradient(loss, conv_outputs)[0]
# Guided Backprop (elimination of negative values)
gate_f = tf.cast(output > 0, 'float32')
gate_r = tf.cast(grads > 0, 'float32')
guided_grads = gate_f * gate_r * grads
# Average weight of filters
weights = tf.reduce_mean(guided_grads, axis=(0, 1))
# Class activation map (cam)
# Multiply values of conv filters with gradient weights
cam = tf.reduce_sum(output * weights, axis=2)
# Rescale to org image size and min-max scale
cam = cv2.resize(cam.numpy(), (224, 224))
cam = np.maximum(cam, 0)
heatmap = (cam - cam.min()) / (cam.max() - cam.min())
# Original image, reshape back, denormalize and adjust type to heatmap
src_1 = img_to_plot
src_1 = np.uint8(255 * src_1)
src_1 = cv2.cvtColor(src_1, cv2.COLOR_RGB2BGR)
# Define color map based on heatmap
src_2 = np.uint8(255 * heatmap)
src_2 = cv2.applyColorMap(src_2, cv2.COLORMAP_RAINBOW)
# Calculates the weighted sum of two arrays:
# dst = src1*alpha + src2*beta + gamma
output_image = cv2.addWeighted(src1=src_1, alpha=0.5, src2=src_2, beta=0.8, gamma=0)
output_dict = {"heatmap": output_image.tolist()}
return jsonify(output_dict)
datasets = {
'PNAS': pnas_dataset.PNASDataset(src_db=src_db),
'Leaves': leaves_dataset.LeavesDataset(src_db=src_db),
'Fossil': fossil_dataset.FossilDataset(src_db=src_db)
}
data = datasets[PARAMS['dataset_name']]
data_config = stuf(threshold=0,
data_splits_meta={
'train':PARAMS['train_size'],
'val':PARAMS['val_size'],
'test':PARAMS['test_size']
}
)
preprocess_input = get_preprocessing_func(PARAMS['model_name'])
preprocess_input(tf.zeros([4, 32, 32, 3]), tf.zeros([4, 32]))
load_example = partial(_load_example, img_size=PARAMS['image_size'], num_classes=data.num_classes)
# class ConfusionMatrixCallback(Callback):
#
# def __init__(self, log_dir, val_imgs, val_labels, classes, freq=1, seed=None):
# self.file_writer = tf.contrib.summary.create_file_writer(log_dir)
# self.log_dir = log_dir
# self.seed = seed
# self._counter = 0
# self.val_imgs = val_imgs
#
# if val_labels.ndim==2:
# val_labels = tf.argmax(val_labels,axis=1)
all_images = pickle.load(f)
with open(path.join(DATA_PATH, 'labels'), 'rb') as f:
all_targets = pickle.load(f)
with open(path.join(DATA_PATH, 'validation'), 'rb') as f:
validation_images = pickle.load(f)
with open(path.join(DATA_PATH, 'validation_labels'), 'rb') as f:
validation_targets = pickle.load(f)
all_images = np.concatenate([all_images, validation_images], axis=0)
all_targets = np.concatenate([all_targets, validation_targets], axis=0)
all_images = np.array(all_images)
all_images = preprocess_input(all_images)
all_targets = all_targets[:, 4:]
all_targets = all_targets.astype(int)
labels_task_1 = [
'Bathroom', 'Bathroom cabinet', 'Bathroom sink', 'Bathtub', 'Bed',
'Bed frame', 'Bed sheet', 'Bedroom', 'Cabinetry', 'Ceiling', 'Chair',
'Chandelier', 'Chest of drawers', 'Coffee table', 'Couch', 'Countertop',
'Cupboard', 'Curtain', 'Dining room', 'Door', 'Drawer', 'Facade',
'Fireplace', 'Floor', 'Furniture', 'Grass', 'Hardwood', 'House', 'Kitchen',
'Kitchen & dining room table', 'Kitchen stove', 'Living room', 'Mattress',
'Nightstand', 'Plumbing fixture', 'Property', 'Real estate',
'Refrigerator', 'Roof', 'Room', 'Rural area', 'Shower', 'Sink', 'Sky',
'Table', 'Tablecloth', 'Tap', 'Tile', 'Toilet', 'Tree', 'Urban area',
'Wall', 'Window'
def preprocess(img):
arr = image.img_to_array(img)
expanded = numpy.expand_dims(arr, axis=0)
preprocessed = preprocess_input(expanded)
return (preprocessed)
