def visualize(self, model, layer_input, save_image=False, path='.'):
#keract_inputs = layer_input[:1]
#keract_inputs = ((layer_input - np.min(layer_input))/ (np.max(layer_input) - np.min(layer_input)) ) + 0.5
keract_inputs = layer_input
activations = get_activations(model, keract_inputs)
display_activations(activations,
save=save_image,
directory=path,
cmap='jet')
def display_activations(self, layer_name: str=None, st=0, en=None, indices=None, **kwargs):
# not working currently
activations = self.activations(st=st, en=en, indices=indices)
if layer_name is None:
activations = activations
else:
activations = activations[layer_name]
keract.display_activations(activations=activations,**kwargs)
def Activation_Keract(self, patientName, X, AllModels, ROINameCollected):
"""
Generate activation maps for each layer
patientName, Input data, AllModels, ROIOfInterest
Output: Keract maps saved in folders
"""
from keract import get_activations, display_activations, display_heatmaps, display_gradients_of_trainable_weights, get_gradients_of_activations, get_gradients_of_trainable_weights
# For all models
for i in range(len(AllModels)):
# Make sure folders exist
activationDir = './ActivationMaps' + '/' + patientName + '/' + ROINameCollected + '/' + 'model_' + str(i) + '/' + 'Activation'
if not os.path.exists(activationDir):
os.makedirs(activationDir)
overlayDir = './ActivationMaps' + '/' + patientName + '/' + ROINameCollected + '/' + 'model_' + str(i) + '/' + 'Overlay'
if not os.path.exists(overlayDir):
os.makedirs(overlayDir)
# Get activations
currActivations = get_activations(AllModels[0], X, layer_names=None, nodes_to_evaluate=None, output_format='full', nested=False, auto_compile=True)
# Save activations only
display_activations(currActivations, cmap=None, save=True, directory=activationDir, data_format='channels_last', fig_size=(24, 24), reshape_1d_layers=False)
# Save acivation overlay
display_heatmaps(currActivations, X, save=True, directory=overlayDir)
def print_convolution_outputs(model, X_test, indexes):
for i in indexes:
activations1 = get_activations(model, X_test[i].reshape(1, 32, 32, 3), layer_name="conv1", auto_compile=True)
activations2 = get_activations(model, X_test[i].reshape(1, 32, 32, 3), layer_name="conv2", auto_compile=True)
activations3 = get_activations(model, X_test[i].reshape(1, 32, 32, 3), layer_name="conv3", auto_compile=True)
keract.display_activations(activations1, cmap=None, save=True, directory='./figures/exercise2_b_'+str(i)+'output')
keract.display_activations(activations2, cmap=None, save=True, directory='./figures/exercise2_b_'+str(i)+'output')
keract.display_activations(activations3, cmap=None, save=True, directory='./figures/exercise2_b_'+str(i)+'output')
model.summary()
#setting all the initial parameters and math for our model
model.compile(optimizer="adam",
loss="sparse_categorical_crossentropy",
metrics=["accuracy"])
#training the model on the training sets
model.fit(x_train, y_train, epochs=150
#testing the model on the testing sets
model.evaluate(x_test, y_test)
model.save('drive/My Drive/Model Files/working_model')
model = tf.keras.models.load_model('drive/My Drive/Model Files/working_model')
"""**Visualizing our model**"""
!pip install keract
from keract import get_activations, display_activations
img = imageList [1]x
img = np.expand_dims (img, axis=0)
activations = get_activations (model, img)
display_activations (activations, save=False)
#image that the filters are working on
plt.imshow(imageList[1])
from io import BytesIO
import requests
from PIL import Image
from keras.applications.inception_v3 import InceptionV3
from keras.applications.inception_v3 import decode_predictions
from keras.applications.inception_v3 import preprocess_input
from keras.preprocessing.image import img_to_array
import keract
model = InceptionV3()
url = 'https://upload.wikimedia.org/wikipedia/commons/thumb/1/14/Gatto_europeo4.jpg/250px-Gatto_europeo4.jpg'
response = requests.get(url)
image = Image.open(BytesIO(response.content))
image = image.crop((0, 0, 299, 299))
image = img_to_array(image)
image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2]))
image = preprocess_input(image)
yhat = model.predict(image)
label = decode_predictions(yhat)
label = label[0][0]
print('{} ({})'.format(label[1], label[2] * 100)) # a tabby is a cat!
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
activations = keract.get_activations(model, image)
keract.display_activations(activations)
def get_anchors(anchors_path):
'''loads the anchors from a file'''
with open(anchors_path) as f:
anchors = f.readline()
anchors = [float(x) for x in anchors.split(',')]
return np.array(anchors).reshape(-1, 2)
anchors = get_anchors(anchors_path)
num_anchors = len(anchors)
yolo_model = yolo_body(Input(shape=(None, None, 3)),
num_anchors // 3,
num_classes=1)
yolo_model.load_weights(model_path)
yolo_model = Model(yolo_model.input, yolo_model.layers[50].output)
yolo_model.compile(loss="mse", optimizer="adam")
print(yolo_model.summary())
# size = 416, 416
X = Image.open(image_path)
X = X.resize((416, 416), Image.BICUBIC)
X = np.array(X, dtype='float32')
# print(X)
X /= 255.
X = np.expand_dims(X, 0) # Add batch dimension.
activations_rpn = keract.get_activations(yolo_model, X)
dp_activations = keract.display_activations(activations_rpn,
cmap='gray',
directory='activations/attention',
save=True)
x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.
x_train = x_train.reshape((len(x_train), np.prod(x_train.shape[1:])))
x_test = x_test.reshape((len(x_test), np.prod(x_test.shape[1:])))
#introducing noise
noise_factor = 0.5
x_train_noisy = x_train + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_train.shape)
x_test_noisy = x_test + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_test.shape)
history = autoencoder.fit(x_train_noisy, x_train,
epochs=10,
batch_size=256,
shuffle=True,
validation_data=(x_test_noisy, x_test_noisy))
[train_loss, train_acc] = autoencoder.evaluate(x_train_noisy, x_train)
[test_loss, test_acc] = autoencoder.evaluate(x_test_noisy, x_test)
input_sample = x_test[:1]
activations = get_activations(encoder, input_sample)
display_activations(activations, cmap="gray", save=False)
# encode and decode some digits
# note that we take them from the *test* set
encoded_imgs = encoder.predict(x_test)
decoded_imgs = decoder.predict(encoded_imgs)
pip install keract
'''
This module takes the model and a sample and creates images in a folder
of the activations throughtout the whole net. Seeing the activations is a
visual tool to check the model behavior, e.g, if some of the latest
layers do not activate, then the network is probably underfitting.
'''
import matplotlib.pyplot as plt
from keras import backend as K
import numpy as np
from keract import get_activations, display_activations
from buildModelFromDisk import buildModelFromDisk
from buildSampleFromDisk import buildSampleFromDisk
model = buildModelFromDisk()
(img, sample) = buildSampleFromDisk('./tests/cannabis.jpg')
activations = get_activations(model, sample)
[print(k, '->', v.shape, '- Numpy array') for (k, v) in activations.items()]
display_activations(activations, save=True, directory="./activations/")
def test_display_1(self):
model, x = dummy_model_and_inputs()
acts = get_activations(model, x)
display_activations(acts, save=True)
b = Dense(1, name='fc2')(i2)
c = concatenate([a, b], name='concat')
d = Dense(1, name='out')(c)
model = Model(inputs=[i1, i2], outputs=[d])
# inputs to the model
x = [np.random.uniform(size=(32, 10)), np.random.uniform(size=(32, 10))]
# call to fetch the activations of the model.
activations = get_activations(model, x, auto_compile=True)
# print the activations shapes.
[print(k, '->', v.shape, '- Numpy array') for (k, v) in activations.items()]
# Print output:
# i1 -> (32, 10) - Numpy array
# i2 -> (32, 10) - Numpy array
# fc1 -> (32, 1) - Numpy array
# fc2 -> (32, 1) - Numpy array
# concat -> (32, 2) - Numpy array
# out -> (32, 1) - Numpy array
keract.display_activations(activations,
cmap=None,
save=False,
directory='.',
data_format='channels_last',
fig_size=(24, 24),
reshape_1d_layers=False)
#%%
from keras.models import load_model
from keract import get_activations, display_activations, display_heatmaps
from pathlib import Path
import matplotlib.pyplot as plt
import numpy as np
#%%
path = Path("/home/killaarsl/Documents/racebaandemo/ADR")
model = load_model(str(path / "tempmodel.h5"))
image = plt.imread(str(path / "434_4_2.png"))
image = image[:, :, :3]
image = np.expand_dims(image, axis=0)
activations = get_activations(model, image)
#%%
display_activations(activations, cmap="gray", save=True)
#%%
display_heatmaps(activations, image, save=False)
def extract_features_to_pd():
# 1. Load Data and CNN Model
DTL = np.load(
os.path.join(cf.DROPBOX_DIRECTORY, 'Data', 'OPM', 'FinalData',
'Individual Datasets', 'bisp_dtl.npy'))
bisp_df = pd.read_pickle(
os.path.join(cf.DROPBOX_DIRECTORY, 'Data', 'OPM', 'FinalData',
'Individual Datasets', 'bisp_dtl_uids.pkl'))
model = load_model(cf.CNN_FILENAME)
# 2. Extract features
layer_name = 'fc1'
#DTL.shape
#DTL[0].shape
i = 0
DTL_i = DTL[(i):(i + 1)]
l1 = DTL_i[0, :, :, 0]
show(l1)
activations = get_activations(model, DTL[0:1])
import keract
keract.display_activations(activations,
cmap=None,
save=False,
directory='.',
data_format='channels_last',
fig_size=(24, 24),
reshape_1d_layers=False)
keract.display_heatmaps(activations, DTL[0:1], save=False)
a.shape
DTL_p = preprocess_input(DTL) # Preprocess image data
#DTL_p = DTL_p[1:5,:,:,:] # for testing
# Generate feature extractor using trained CNN
feature_extractor = Model(
inputs=model.inputs,
outputs=model.get_layer(name=layer_name).output,
)
features = feature_extractor.predict(DTL_p)
# 3. Create and format pandas DataFrame
df = pd.DataFrame(features).add_prefix('cnn_feat_')
df['uid'] = bisp_df.uid
# 4. Export
df.to_pickle(
os.path.join(cf.DROPBOX_DIRECTORY, 'Data', 'OPM', 'FinalData',
'Individual Datasets', 'bisp_cnn_features_all.pkl'))
df.to_csv(
os.path.join(cf.DROPBOX_DIRECTORY, 'Data', 'OPM', 'FinalData',
'Individual Datasets', 'bisp_cnn_features_all.csv'))
model.add(Conv2D(10, kernel_size=(5, 5), activation='relu'))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dense(no_classes, activation='softmax'))
#compile the model
model.compile(loss=tf.keras.losses.categorical_crossentropy, optimizer=tf.keras.optimizers.Adam(), metrics=['accuracy'])
#fit data to model
model.fit(input_train, target_train, batch_size=batch_size, epochs=no_epochs, verbose=verbosity, validation_split=validation_split)
#generate generalization metrics
score=model.evaluate(input_test, target_test, verbose=0)
print(f'Test loss: {score[0]} / Test accuracy: {score[1]}')
#keract visualizations
#for each layer
from keract import get_activations, display_activations
keract_inputs=input_test[:1]
keract_target=target_test[:1]
activations=get_activations(model, keract_inputs)
display_activations(activations, cmap='gray', save=False)
#heatmaps
from keract import display_heatmaps
display_heatmaps(activations, keract_inputs, save=False)
#loads the model from the saved model file
json_file = open('model.json', 'r')
mapping = {'LeakyRelu': LeakyRelu}
loaded_model_json = json_file.read()
json_file.close()
model = model_from_json(loaded_model_json, mapping)
# load weights into new model
model.load_weights("model.h5")
#keract requires model compilation
model.compile(loss="mse", optimizer="adam")
while True:
#generates the noise to be fed into the model
noise = np.random.normal(0, 1, (1, 100))
#shows the reshape layer as it has image output
activations = get_activations(model, noise, model.layers[4].name)
display_activations(activations, cmap="gray")
for layer in model.layers:
#shows only the batch norm layers to avoid seeing conv then batch norm when they are quite similar
if "norm" in layer.name:
activations = get_activations(model, noise, layer.name)
display_activations(activations, cmap="gray")
#the last layer doesn't have any batch norm but we want to see it anyway
output = reverse_tanh(model.predict(noise)[0])
plt.imshow(output)
plt.show()
plt.figure()
plt.imshow(Image.fromarray(u[0, :, :, :], 'RGB'))
plt.axis('off')
pred_class = np.argmax(model.predict(u, verbose=1))
plt.title('Predicted #: {}'.format(pred_class))
plt.savefig('./visuals/00_test_image.png')
print('Done.\n')
#%% feature maps
print('Plotting and saving activations...\n')
keract.display_activations(activations,
cmap='viridis',
save=True,
directory='./visuals/',
data_format='channels_last')
# keract.display_heatmaps(activations, u, save=True)
print('\nDone.\n')
#%% Layer Viz - Filters
#Select a convolutional layer
layer = model.layers[0]
#Get weights
kernels, biases = layer.get_weights()
#Normalize kernels into [0, 1] range for proper visualization
# checking that the accuracy is the same as before 99% at the first epoch.
# test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0, batch_size=128)
# print('')
# assert test_acc > 0.98
utils.print_names_and_shapes(
keract.get_activations(model, x_test[0:200])) # with 200 samples.
utils.print_names_and_shapes(
keract.get_gradients_of_trainable_weights(model, x_train[0:10],
y_train[0:10]))
utils.print_names_and_shapes(
keract.get_gradients_of_activations(model, x_train[0:10],
y_train[0:10]))
a = keract.get_activations(model, x_test[0:1]) # with just one sample.
keract.display_activations(a, directory='mnist_activations', save=True)
# import numpy as np
# import matplotlib.pyplot as plt
# plt.imshow(np.squeeze(x_test[0:1]), interpolation='None', cmap='gray')
else:
x_train, y_train, x_test, y_test = MNIST.get_mnist_data()
model = Sequential()
model.add(
Conv2D(32,
kernel_size=(3, 3),
activation='relu',
input_shape=MNIST.input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
def test_display_2(self):
acts = {'1_channel': np.random.uniform(size=(1, 32, 32, 1))}
display_activations(acts, save=True)
metrics=['accuracy'])
print(model.summary())
x_train, y_train, x_test, y_test = get_mnist_data()
# checking that the accuracy is the same as before 99% at the first epoch.
# test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0, batch_size=128)
# print('')
# assert test_acc > 0.98
utils.print_names_and_shapes(get_activations(
model, x_test[0:200])) # with 200 samples.
a = get_activations(model, x_test[0:1]) # with just one sample.
display_activations(a)
# import numpy as np
# import matplotlib.pyplot as plt
# plt.imshow(np.squeeze(x_test[0:1]), interpolation='None', cmap='gray')
else:
x_train, y_train, x_test, y_test = get_mnist_data()
model = Sequential()
model.add(
Conv2D(32,
kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
def TopOpt_Designing(User_Conditions, opts, envs, my_call_back_functions):
Time_Trial = opts.Time_Trial
if opts.Progressive_Refinement:
agent_primer = Agent(envs.env_primer,
opts,
Increase=False,
filename_save=opts.filename_save +
str(opts.PR_EX) + 'by' + str(opts.PR_EY),
filename_load=opts.filename_load,
EX=opts.PR_EX,
EY=opts.PR_EY,
n_actions=opts.PR_EX * opts.PR_EY,
epsilon=0,
input_dims=[opts.PR_EX, opts.PR_EY, 3])
agent_primer2 = Agent(envs.env_primer2,
opts,
Increase=False,
filename_save=opts.filename_save +
str(opts.PR2_EX) + 'by' + str(opts.PR2_EY),
filename_load=opts.filename_load,
EX=opts.PR2_EX,
EY=opts.PR2_EY,
n_actions=opts.PR2_EX * opts.PR2_EY,
epsilon=0,
input_dims=[opts.PR2_EX, opts.PR2_EY, 3])
agent_primer.load_models()
agent_primer2.load_models()
agent = Agent(envs.env,
opts,
Increase=False,
filename_save=opts.filename_save + str(opts.Main_EX) + 'by' +
str(opts.Main_EY),
filename_load=opts.filename_load,
EX=opts.Main_EX,
EY=opts.Main_EY,
n_actions=opts.Main_EX * opts.Main_EY,
epsilon=1.0,
input_dims=[opts.Main_EX, opts.Main_EY, 3])
if opts.Load_Checkpoints: agent.load_models()
figure_file = 'plots/' + opts.filename_save + '_reward.png'
best_score = envs.env.reward_range[0]
score_history, per_history, succ_history, Loss_history = [], [], [], []
if not opts.Load_Checkpoints:
from pandas import DataFrame
TrialData = DataFrame(columns=[
'Episode', 'Reward', 'Successfull Steps', 'Percent Successful',
'Avg Loss', 'SDEV', 'Epsilon', 'Time'
])
envs.env.reset_conditions()
if opts.From_App: opts.n_games = 1
for i in range(opts.n_games):
Testing = False #Used to render the environment and track learning of the agent
if opts.Load_Checkpoints:
'If the user wants to test the agent, the user will be prompted to input BC and LC elements'
if opts.From_App:
App_Inputs(envs.env, envs.env_primer, envs.env_primer2, opts,
User_Conditions)
else:
User_Inputs(envs.env, opts)
done = False
score = 0
if i % 10 == 0 and i >= 100:
Testing = True
if i % 200 == 0:
'Every 200 episodes, a special BC/LC will be used for monitoring purposes'
Testing_Inputs(envs.env, opts)
print('--------Testing Run------')
envs.env.VoidCheck = list(np.ones((1, envs.env.EX * envs.env.EY))[0])
if Time_Trial: Start_Time_Trial = time.perf_counter()
observation = envs.env.reset()
print(envs.env)
if opts.Progressive_Refinement:
''' Set Up to Complete 3 Iterations of Progressive Refinement'''
#Progressive Refinement #1 Going from Smallest to Intermediate Mesh Size
envs.env_primer.VoidCheck = list(
np.ones((1, envs.env_primer.EX * envs.env_primer.EY))[0])
Prog_Refine_Act(agent_primer,
envs.env,
envs.env_primer,
opts.Load_Checkpoints,
Testing,
opts,
opts.PR_EX,
opts.PR_EY,
Time_Trial,
opts.From_App,
FEA_Skip=1)
#Progressive Refinement #2 Going for Intermediate to Final Mesh Size
envs.env_primer2.VoidCheck = Mesh_Transform(
opts.PR_EX, opts.PR_EY, opts.PR2_EX, opts.PR2_EY,
envs.env_primer.VoidCheck)
if opts.From_App:
del agent_primer
Prog_Refine_Act(agent_primer2,
envs.env,
envs.env_primer2,
opts.Load_Checkpoints,
Testing,
opts,
opts.PR2_EX,
opts.PR2_EY,
Time_Trial,
opts.From_App,
FEA_Skip=1)
#This outcome will now be used as the final mesh Size
envs.env.VoidCheck = Mesh_Transform(opts.PR2_EX, opts.PR2_EY,
opts.Main_EX, opts.Main_EY,
envs.env_primer2.VoidCheck)
if opts.From_App:
del agent_primer2
#Removed_Num=Mesh_Triming(env_primer,PR_EX,PR_EY)
#Uncomment the above line if you want to incorporate mesh trimming
observation[:, :, 0] = np.reshape(
FEASolve(envs.env.VoidCheck,
opts.Lx,
opts.Ly,
opts.Main_EX,
opts.Main_EY,
envs.env.LC_Nodes,
envs.env.Load_Directions,
envs.env.BC_Nodes,
Stress=True)[3], (opts.Main_EX, opts.Main_EY))
observation_v, observation_h, observation_vh = obs_flip(
observation, opts.Main_EX, opts.Main_EY)
Last_Reward = 0
while not done:
if i % 1000 == 0 and i >= 1: #Every 1000 iterations, show the activation maps
from keract import get_activations, display_activations
activations = get_activations(
agent.q_eval.model,
observation.reshape(-1, opts.Main_EX, opts.Main_EY, 3))
display_activations(activations, save=False)
action = agent.choose_action(observation, opts.Load_Checkpoints,
Testing)
observation_, reward, done, It = envs.env.step(
action,
observation,
Last_Reward,
opts.Load_Checkpoints,
envs.env,
FEA_Skip=1,
PR=False)
if not opts.Load_Checkpoints:
observation_v_, observation_h_, observation_vh_ = obs_flip(
observation_, opts.Main_EX, opts.Main_EY)
action_v, action_h, action_vh = action_flip(
action, opts.Main_EX, opts.Main_EY)
agent.store_transition(observation, action, reward,
observation_, done)
agent.store_transition(observation_v, action_v, reward,
observation_v_, done)
agent.store_transition(observation_h, action_h, reward,
observation_h_, done)
agent.store_transition(observation_vh, action_vh, reward,
observation_vh_, done)
score += reward
App_Plot = Testing_Info(envs.env,
envs.env_primer,
envs.env_primer2,
opts,
score,
opts.Progressive_Refinement,
opts.From_App,
Fixed=True)
_ = [fn(App_Plot) for fn in my_call_back_functions]
Last_Reward = reward
if Testing and not Time_Trial:
envs.env.render()
print('Current Score: ' + str(round(score, 3)))
observation = observation_
if not opts.Load_Checkpoints:
observation_v = observation_v_
observation_h = observation_h_
observation_vh = observation_vh_
if opts.Load_Checkpoints and not Time_Trial: envs.env.render()
App_Plot = Testing_Info(envs.env,
envs.env_primer,
envs.env_primer2,
opts,
score,
opts.Progressive_Refinement,
opts.From_App,
Fixed=True)
_ = [fn(App_Plot) for fn in my_call_back_functions]
return App_Plot
toc = time.perf_counter()
if Time_Trial and not opts.From_App:
print('It took ' + str(round(toc - Start_Time_Trial, 1)) +
' seconds to complete this time trial.')
App_Plot = Testing_Info(envs.env,
envs.env_primer,
envs.env_primer2,
opts,
score,
opts.Progressive_Refinement,
opts.From_App,
Fixed=True)
item_prefixes = {
'primarycap_reshape/Reshape:0': 'model9_primarycap_layer_item',
'conv/Relu:0': 'model9_conv_layer_item'
}
import pathlib
path = pathlib.Path(folder_path)
path.mkdir(mode=0o766, parents=True, exist_ok=True)
for item_num in items:
a = get_activations(model, X_train[item_num -
1:item_num]) # with just one sample.
plt.title('Train image #' + str(item_num))
plt.imshow(X_train[item_num])
plt.savefig(folder_path + image_prefix + str(item_num) + '.png',
format='png')
retrieved_activations = {}
for k, v in a.items():
if k == 'primarycap_reshape/Reshape:0':
retrieved_activations[k] = v.reshape(1, 8, 8, 32 * 12)
retrieved_activations[k] = retrieved_activations[k][:, :, :, :48]
elif k == 'conv/Relu:0':
retrieved_activations[k] = v[:, :, :, :48]
dumpclean(a)
display_activations(retrieved_activations, item_num, folder_path,
item_prefixes)
from tensorflow.keras.applications.vgg16 import VGG16
from tensorflow.keras.applications.vgg16 import decode_predictions
from tensorflow.keras.applications.vgg16 import preprocess_input
from tensorflow.keras.preprocessing.image import img_to_array
import keract
from utils import gpu_dynamic_mem_growth
if __name__ == "__main__":
# Check for GPUs and set them to dynamically grow memory as needed
# Avoids OOM from tensorflow greedily allocating GPU memory
gpu_dynamic_mem_growth()
model = VGG16()
image = Image.open('250px-Gatto_europeo4.jpeg')
image = image.crop((0, 0, 224, 224))
image = img_to_array(image)
image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2]))
image = preprocess_input(image)
yhat = model.predict(image)
label = decode_predictions(yhat)
label = label[0][0]
print('{} ({})'.format(label[1], label[2] * 100))
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
activations = keract.get_activations(model, image)
first = activations.get('block1_conv1')
keract.display_activations(activations, save=True)
validation_steps=64,
callbacks=[tb_callback, cp_callback])
print('TRAINING COMPLETE')
model.save(MODEL_STRUCT_PATH)
for dp in glob(os.path.join(TEST_DATA_PATH, '*')):
for fp in glob(os.path.join(TEST_DATA_PATH, dp, '*')):
(fn, _) = os.path.splitext(fp)
arr = numpy.array(
load_img(fp,
target_size=(SIGN_IMG_HEIGHT, SIGN_IMG_WIDTH),
grayscale=False,
color_mode='rgb',
interpolation='nearest'))
a = get_activations(model, [[arr]], auto_compile=True)
rp = os.path.join(KERACT_PATH, relative_path(fn, TEST_DATA_PATH))
display_activations(a, directory=rp, save=True)
print(f'VISUALIZATION SAVED: {rp}')
break
print('DONE')
yp = model.predict_generator(test_generator)
yp = numpy.argmax(yp, axis=1)
print('CONFUSION MATRIX:')
print(confusion_matrix(test_generator.classes, yp))
print('Classification Report')
print(classification_report(test_generator.classes, yp, target_names=TYPES))
raw_image_string = tf.io.read_file(img_path)
raw_image = tf.image.decode_jpeg(raw_image_string, channels=3)
raw_image = tf.image.convert_image_dtype(raw_image, tf.float32)
raw_image = tf.image.resize(raw_image, [680, 460])
raw_image = tf.clip_by_value(raw_image, 0.0, 1.0)
image = tf.reshape(raw_image, (-1, 680, 460, 3))
print('=================================================')
activations = keract.get_activations(loaded_model, image)
[
print(k, '->', v.shape, '- Numpy array')
for (k, v) in activations.items()
]
if args.mode == 'act_map':
keract.display_activations(activations, cmap="gray")
elif args.mode == 'heat_map':
keract.display_heatmaps(activations, image, save=False)
print('=================================================')
if args.v:
json_path = os.path.join(args.model_dir, "affine_weights.json")
weights = loaded_model.get_weights()
print("[INFO] affine transformation params: ")
[print("\t Theta -> ", w) for (w) in weights[-1]]
print('=================================================')
out_image = loaded_model(image)
IMG_SHAPE = (680, 460, 3)
sampling_size = (240, 240)
