def test_load_config(self): load_config(self.config_path) with open(self.config_path, "r") as f: obj = json.load(f) for k, v in obj.iteritems(): assert getattr(config, k, None) == v assert config.RGB_MEAN == [123.68, 116.779, 103.939]
def main(): config = load_config(SERVER_CONFIG_PATH) local_host = config.get("server_ip") #local_host = get_ip_address(config.get("local_interface")) rpc_port = config.get("rpc_port") rpc_server = ThreadingXMLRPCServer((local_host, rpc_port), logRequests=False) #rpc_server.register_function(sign_in) #rpc_server.register_function(howru) rpc_server.register_instance(MonServer()) threadinglize(rpc_server.serve_forever, "rpc_server")() logger.info("start RPC server on %s:%d" % (local_host, rpc_port)) rrd_root = config.get("RRD_root", "/dev/shm") rrd_handler = RRDHandler.getInstance(rrd_root) ds_port = config.get("ds_port") data_server = DataReciever((local_host, ds_port), rrd_handler) threadinglize(data_server.serve_forever, "data_server")() logger.info("start data server on %s:%d" % (local_host, ds_port)) #model_int = Interface() agent_timeout = config.get("agent_timeout") check_alive_interval = config.get("check_alive_interval") scheduled_task(check_alive, "check_alive", True, 0, -1, check_alive_interval)(agent_timeout) logger.info("check_alive started...") while True: myprint(threading.enumerate()) sleep(60)
def main(): config = load_config() Base.metadata.create_all(engine) # loop = asyncio.get_running_loop() # loop.run_in_executor(main) app = web.Application() app.add_routes( [web.get('/notes', get_notes), web.post('/notes', post_note)]) web.run_app(app, port=config['port'])
def get_connection(db_type='oracle'): logging.info("Connecting to db.") config = load_config() if db_type == 'oracle': if get_connection.oracle_conn is None: config = config['oracle_db'] dsn_config = config['dsn'] dsn_tns = cx_Oracle.makedsn(**dsn_config) connection_config = config['connection'] connection_config['dsn'] = dsn_tns get_connection.oracle_conn = cx_Oracle.connect(**connection_config) return get_connection.oracle_conn elif db_type == 'hive': if get_connection.hive_conn is None: config = config['hive_db'] get_connection.hive_conn = hive.Connection(**config) return get_connection.hive_conn else: raise ValueError("DB Type can be : 'oracle' or 'hive' ")
if save: plt.savefig( os.path.join("models/saved", config['config_name'], "_direction_scatter.png")) if __name__ == '__main__': """ Example of use 2021/01/04 - model is trained in separate steps (specified in config) """ config = load_config("norm_base_plotDirections_t0012.json") save_name = config["sub_folder"] retrain = False # model try: if retrain: raise IOError("retrain = True") norm_base = NormBase(config, input_shape=(224, 224, 3), save_name=save_name) except IOError: norm_base = NormBase(config, input_shape=(224, 224, 3)) norm_base.fit(load_data(config, train=config["train_dim_ref_tun_ref"][0]),
2021/01/21 This script checks the format of the dataset and its influence. The documentation (https://keras.io/api/applications/vgg/) says: "Note: each Keras Application expects a specific kind of input preprocessing. For VGG19, call tf.keras.applications.vgg19.preprocess_input on your inputs before passing them to the model." """ import os import numpy as np import tensorflow as tf from utils.load_config import load_config from utils.load_data import load_data from plots_utils.plot_cnn_output import plot_cnn_output # parameter config = load_config("norm_base_animate_cnn_response_t0001.json") path ="models/saved/check_image_format" if not os.path.exists(path): os.mkdir(path) # load images images,_ = load_data(config, train=config["dataset"]) image = images[0] # check format, i expect RGB [0..255] print("original shape:", image.shape) print("original format:", image.dtype) print("original value range:", [np.min(image), np.max(image)]) #original shape: (224, 224, 3) #original format: float64 #original value range: [0.0, 237.0]
import numpy as np from utils.load_config import load_config from utils.load_data import load_data from models.ExampleBase import ExampleBase from datasets_utils.expressivity_level import segment_sequence from plots_utils.plot_expressivity_space import plot_expressivity_level """ Reproduce the results from the ICANN paper but with the updated VGG pipeline run: python -m projects.dynamic_facial_expressions_ICANN.03_reproduce_ICANN_ExampleBase """ # load config # config = load_config("EB_reproduce_ICANN_cat.json", path="configs/example_base") config = load_config("EB_reproduce_ICANN_expressivity.json", path="configs/example_base") # load model model = ExampleBase(config, input_shape=tuple(config['input_shape']), load_EB_model=False) # -------------------------------------------------------------------------------------------------------------------- # train model # load data train_data = load_data(config) train_data[0] = segment_sequence(train_data[0], config['train_seg_start_idx'], config['seq_length']) train_data[1] = segment_sequence(train_data[1], config['train_seg_start_idx'], config['seq_length'])
run: python -m tests.NormBase.t11a_dynamic_weighted_xy_pos """ # define configuration config_path = 'NB_t11a_dynamic_xy_pos_m0003.json' # declare parameters best_eyebrow_IoU_ft = [209, 148, 59, 208] best_lips_IoU_ft = [ 77, 79, 120, 104, 141, 0, 34, 125, 15, 89, 49, 237, 174, 39, 210, 112, 111, 201, 149, 165, 80, 42, 128, 74, 131, 193, 133, 44, 154, 101, 173, 6, 148, 61, 27, 249, 209, 19, 247, 90, 1, 255, 182, 251, 186, 248 ] # load config config = load_config(config_path, path='configs/norm_base_config') # create directory if non existant save_path = os.path.join("models/saved", config["config_name"]) if not os.path.exists(save_path): os.mkdir(save_path) # load and define model v4_model = load_extraction_model(config, input_shape=tuple(config["input_shape"])) v4_model = tf.keras.Model(inputs=v4_model.input, outputs=v4_model.get_layer( config['v4_layer']).output) size_ft = tuple(np.shape(v4_model.output)[1:3]) print("[LOAD] size_ft", size_ft) print("[LOAD] Model loaded")
""" 2020/12/07 This script plots the result from evaluate_all_nu.py """ import os import numpy as np import matplotlib.pyplot as plt from utils.load_config import load_config config = load_config("norm_base_affectNet_sub8_4000_t0006.json") if isinstance(config['nu'], list): nus = config['nu'] else: nus = [config['nu']] accuracies = np.zeros(len(nus)) for i, nu in enumerate(nus): config['nu'] = nu save_folder = os.path.join("../../models/saved", config['save_name'], 'nu_%f' % nu) accuracy = np.load(os.path.join(save_folder, "accuracy.npy")) accuracies[i] = accuracy # create plot fig = plt.figure(figsize=(15, 10)) plt.plot(nus, accuracies, marker='x') plt.title("Accuracy over nu") plt.xlabel("nu")
config_path = 'CNN_t03a_feature_map_positions_face_shape_m0001.json' # declare parameters eyebrow_ft_idx = [ 148, 209, 208, 67, 211, 141, 90, 196, 174, 179, 59, 101, 225, 124, 125, 156 ] # from t02_find_semantic_units lips_ft_idx = [ 79, 120, 125, 0, 174, 201, 193, 247, 77, 249, 210, 149, 89, 197, 9, 251, 237, 165, 101, 90, 27, 158, 154, 10, 168, 156, 44, 23, 34, 85, 207 ] ft_idx = [eyebrow_ft_idx, lips_ft_idx] slice_pos_eyebrow = 9 slice_pos_lips = 13 # load config config = load_config(config_path, path='configs/CNN') # create directory if non existant save_path = os.path.join("models/saved", config["config_name"]) if not os.path.exists(save_path): os.mkdir(save_path) # load and define model model = load_extraction_model(config, input_shape=tuple(config["input_shape"])) model = tf.keras.Model(inputs=model.input, outputs=model.get_layer(config['v4_layer']).output) size_ft = tuple(np.shape(model.output)[1:3]) print("[LOAD] size_ft", size_ft) print("[LOAD] Model loaded") print()
# mode: maximum, maximum10, weighted average # n_feature_map: ???, 1 plot for each map # plot: columns: picture, response, position mode i --> 5 columns # rows: expressions*avatars*frame --> 8 rows #params n_feature_map = 54 # seems to be the one with moving eyebrow frame_neutral_human_expression = 0 frame_expression_human_expression = 68 frame_neutral_monkey_expression = 0 frame_expression_monkey_expression = 52 mode_list = ["maximum", "maximum10", "weighted average"] # load config config = load_config("norm_base_calculate_position_demo_t0001.json") # load data images_human_fear = load_data(config, train=1)[0] images_monkey_threat = load_data(config, train=2)[0] # reduce data selection_human_expression = [ frame_neutral_human_expression, frame_expression_human_expression, 150 + frame_neutral_human_expression, 150 + frame_expression_human_expression ] selection_monkey_expression = [ frame_neutral_monkey_expression, frame_expression_monkey_expression, 150 + frame_neutral_monkey_expression, 150 + frame_expression_monkey_expression ] images = np.concatenate([
# # # plot # plt.figure() # plt.plot(preds1[:, -1, -1, 0], label="conv1") # plt.plot(preds2[:, -1, -1, 0], label="block3_pool") # plt.plot(raw_data[:, -1, -1, 0], label="pixel") # plt.legend() # plt.title("amplification conv1 vs. block3_pool") # plt.savefig(os.path.join("models/saved", config["config_name"], "05_amplification_fm1.png")) # ------------------------------------------------------------------------------------------------------------------ # test 6: test martin image import pandas as pd config_name = 'CNN_t01_martin_test_m0001.json' config = load_config(config_name, path='configs/CNN') if not os.path.exists(os.path.join("models/saved", config["config_name"])): os.mkdir(os.path.join("models/saved", config["config_name"])) # load csv df = pd.read_csv(config['csv'], index_col=0) # df["category"] = df["category"].astype(int) # get only human c2 = category 1 category = "1" df = df[df['category'].isin([category])] # load data data = load_from_csv(df, config) print("shape data", np.shape(data[0]))
loss = compute_loss(obs, actions, weights=rewards2go) loss.backward() optimizer.step() return for epoch in range(config.epochs): epoch_mean_reward = run_epoch() writer.add_scalar(args.run_name + '_mean_epoch_reward', epoch_mean_reward, epoch) train() return if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--config', type=str, default='config/reinforce.yaml') parser.add_argument('--run_name', type=str, default='reinforce_exp') args = parser.parse_args() config = load_config('config/reinforce.yaml') writer = SummaryWriter(config.logdir) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # Should store configs in some log file for easy matching against TensorBoard runs. for key, value in config._asdict().items(): print(f'{key}: {value}') REINFORCE(config) writer.close()
help='log file location.') parser.add_argument('--steps', type=int, default=1000, help='Number of self-play games and training steps.') parser.add_argument('--checkpoint_freq', type=int, default=250, help='Number of steps between each checkpoint.') parser.add_argument('--update_freq', type=int, default=100, help='Frequency of step and time updates') ARGS = parser.parse_args() config = load_config(ARGS.config_file) checkpoint_dir = './checkpoints' model_dir = './models' game_history_dir = './game_history' replay_memory_dir = './replay_memory' for directory in [ checkpoint_dir, model_dir, game_history_dir, replay_memory_dir ]: if not os.path.exists(directory): os.makedirs(directory) torch.manual_seed(config.random_seed) np.random.seed(config.random_seed)
import numpy as np from utils.load_config import load_config from utils.PatternFeatureReduction import PatternFeatureSelection np.set_printoptions(precision=3) """ small script to test the Pattern feature selection pipeline using RBF templates run: python -m tests.RBF.t02_pattern_ft_selection """ # define configuration config_path = 'RBF_t02_pattern_ft_selection_m0001.json' # load config config = load_config(config_path, path='configs/RBF') data = np.zeros((7, 7)) data[1, 1] = .2 data[1, 2] = .5 data[1, 3] = .2 data[2, 1] = .5 data[2, 2] = 1 data[2, 3] = .5 data[3, 1] = .2 data[3, 2] = .5 data[3, 3] = .2 print("data") print(data) # expand data for RBF data = np.expand_dims(data, axis=0) data = np.expand_dims(data, axis=3)
from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker from sqlalchemy import create_engine from utils.load_config import load_config Base = declarative_base() engine = create_engine(load_config()['database'], echo=True) Session = sessionmaker(bind=engine)
import unittest import sys import os import numpy as np import cv2 import pycocotools.mask from pycocotools.coco import COCO if __name__ == "__main__": sys.path.insert(0, os.getcwd()) from utils.image import * from utils.load_config import load_config load_config() import config class TestImage(unittest.TestCase): def setUp(self): self.annotations_file = "data/coco/annotations/instances_minival2014.json" if getattr(self, 'coco', None) is None: self.coco = COCO(self.annotations_file) image_name = config.IMAGE_NAME_FORMAT % ('val2014', self.coco.getImgIds()[0]) image_path = config.IMAGE_PATH_FORMAT % ('val2014', image_name) self.image = load_image(image_path) def test_load_image(self): blob = sub_mean(self.image) image_mean = np.mean(np.mean(self.image, axis=0), axis=0)
- "weighted average": plot index of weighted average of activation - config["highlight_option"]: choose which feature maps to highlight, based on plotted property (plot_vector) - "maximum": highlight maps with maximum value - config["plot_reduce"]: if True reduces the displayed feature maps to selection in highlight, improves performance """ <<<<<<< HEAD # load config # t0001: human_anger, t0002: human_fear, t0003: monkey_anger, t0004: monkey_fear --> plot cnn_output # t0005: human_anger, t0006: human_fear, t0007: monkey_anger, t0008: monkey_fear --> plot difference, stride3, highlight max # t0009: human_anger, t0010: human_fear, t0011: monkey_anger, t0012: monkey_fear --> plot difference, first, highlight max # t0013: human_anger, t0014: human_fear, t0015: monkey_anger, t0016: monkey_fear --> plot difference, first, reduce max # t0017: human_anger --> plot difference, stride3, reduce max # t0100: human_anger --> plot maximum # t0104: human_anger --> plot weighted average # t0108: human_anger --> plot 10 biggest values (maximum10) config = load_config("norm_base_animate_cnn_response_t0001.json", path="configs/norm_base_config") # load images images,_ = load_data(config, train=config["dataset"]) # load model normbase = NormBase(config,(224,224,3)) # calculate vector and options for plot if config["plot_option"]=='cnn_output': # plot cnn_response vector_plot = normbase.evaluate_v4(images, flatten=False) elif config["plot_option"]=='cnn_output_difference': # take difference between response and reference, reference has different options response = normbase.evaluate_v4(images, flatten=False) if config["difference_option"]=='first':
""" import os import numpy as np import matplotlib.pyplot as plt from utils.load_config import load_config from models.NormBase import NormBase from utils.load_data import load_data config_names = [ "norm_base_data_distance_t0001.json", "norm_base_data_distance_t0002.json" ] models = [] for i, config_name in enumerate(config_names): config = load_config(config_name, path="configs/norm_base_config") save_name = config["sub_folder"] retrain = False # model try: if retrain: raise IOError("retrain = True") norm_base = NormBase(config, input_shape=(224, 224, 3), save_name=save_name) except IOError: norm_base = NormBase(config, input_shape=(224, 224, 3)) norm_base.fit(load_data(config, train=config["train_dim_ref_tun_ref"][0]),
""" import os import numpy as np import matplotlib.pyplot as plt from utils.load_config import load_config from models.NormBase import NormBase # t0001: 2-norm t0002: 1-norm t0003: simplified t0004: direction-only t0005: expressitivity-direction # t0006: 2-norm-monkey_morph do_reverse = False do_normalize = False config = load_config("norm_base_reproduce_ICANN_t0015.json", path="configs/norm_base_config") save_name = config["sub_folder"] save_folder = os.path.join("models/saved", config['save_name'], save_name) accuracy = np.load(os.path.join(save_folder, "accuracy.npy")) it_resp = np.load(os.path.join(save_folder, "it_resp.npy")) labels = np.load(os.path.join(save_folder, "labels.npy")) norm_base = NormBase(config, input_shape=(224, 224, 3)) print("accuracy", accuracy) print("it_resp.shape", it_resp.shape) print("labels.shape", labels.shape) # colors 0=Neutral=Black, 1=Threat=Yellow, 2=Fear=Blue, 3=LipSmacking=Red colors = config['colors'] titles = config['condition'] seq_length = config['seq_length']
test = np.arange(36) n_feature_map = 4 feature_map_size = 3 t = np.reshape(test, (feature_map_size, feature_map_size, n_feature_map)) print(t[:, :, 0]) print(t[:, :, 1]) print(t[:, :, 2]) print(t[:, :, 3]) x, y, z = np.unravel_index(17, (feature_map_size, feature_map_size, n_feature_map)) #x, y, z = get_feature_map_index(17, n_feature_map, feature_map_size) print("({}, {}, {})".format(x, y, z)) # load configuration config_name = "norm_base_investigate_PCA_m0001.json" config = load_config(config_name) # fit models with each condition avatars = ["human_orig", "monkey_orig", "all_orig"] # avatars = ["human_orig"] indexes = [] # pca_threshold = [300, 300, 1500] pca_threshold = [600, 600, 2000] for i, avatar in enumerate(avatars): # modify condition according to loop config['train_avatar'] = avatar # define and train norm base model norm_base = NormBase(config, input_shape=(224, 224, 3)) norm_base.pca.var_threshold = pca_threshold[i] norm_base.fit(load_data(config, train=True),
- use selection_array to reduce the array of positions (recommended by Tim) - use highlight_intersect to reduce the feature maps """ import numpy as np import matplotlib.pyplot as plt import os from utils.load_config import load_config from utils.load_data import load_data from models.NormBase import NormBase from utils.plot_cnn_output import plot_cnn_output from utils.calculate_position import calculate_position # load config config = load_config("norm_base_config_plot_frequency_time_t0001.json") # load data --> 150 x 224 x 224 x 3 images,_ = load_data(config, train=1) # load NormBase norm_base = NormBase(config, (224,224,3)) # (train NormBase)--> maybe necessary, but not atm # get_preds --> 150 x 512, x and y concatenated positions = norm_base.get_preds(images) # calculate fft over time and leave out constant term rfft = np.fft.rfft(positions, axis=0) rfft_abs = np.abs(rfft)
import os from plots_utils.plot_sequence import plot_sequence from utils.load_config import load_config from utils.load_data import load_data from models.NormBase import NormBase """ test a face transfer using norm base mechanism run: python -m projects.facial_shape_expression_recognition_transfer.03_face_part_semantic_feature_map_selection """ # load config config_name = 'NB_morph_space_semantic_pattern_m0002.json' config = load_config(config_name, path='configs/norm_base_config') full_train = False # -------------------------------------------------------------------------------------------------------------------- # train model if full_train: # declare model model = NormBase(config, input_shape=tuple(config['input_shape'])) # load data data = load_data(config) # fit model face_neurons = model.fit(data)
import tornado.ioloop from tornado import ioloop, web from tornado.platform.asyncio import AsyncIOMainLoop from handlers.add_packages_handler import AddPackagesHandler from handlers.get_packages_handler import GetPackagesHandler from handlers.hello_handler import HelloHandler from handlers.package_info_handler import PackageInfoHandler from package_management.package_manager import PackageManager from package_management.paths_util import PathsUtil from package_retention.retention_manager import RetentionManager from security.privilege_validator import PrivilegeValidator from utils import load_config import os config = load_config.load_config() def setup_logging(): logger = logging.getLogger() formatter = logging.Formatter("%(asctime)s [%(levelname)s] - %(message)s") logger.setLevel(logging.DEBUG) logs_folder = config['logsFolder'] os.makedirs(logs_folder, exist_ok=True) file_handler = RotatingFileHandler(os.path.join(logs_folder, 'zippero-server.log'), maxBytes=1024 * 1024 * 10, backupCount=3)
def server(argv): args = ctparser.parse_args(argv) confFile = 'conf/server.yaml' if len(args.conf) == 0 else os.path.join( odir, args.conf) config = load_config('conf/server.yaml.template') config_new = load_config(confFile) update_config(config, config_new) if len(args.override) > 0: for line in args.override.split(';'): exec('config.' + line) if args.port > 0: config.tornado.port = args.port signal.signal(signal.SIGINT, signal_handler) settings = { "template_path": os.path.join(os.path.dirname(__file__), "public"), "cookie_secret": config.tornado.secret, "xsrf_cookies": config.tornado.xsrf, "login_url": "/p/login", "static_path": "public" } import handler from auth import authFuncs from file import fileCache from model import modelCache from task import taskCache from user import userCache from utils.conn2db import conn2db conn = conn2db(config) cfile = fileCache(conn, config) cmodel = modelCache(conn, config) ctask = taskCache(conn, config) cuser = userCache(conn, config) cauth = authFuncs(conn, config, cfile, cuser, ctask, cmodel) RSettings = { 'authCache': cauth, 'userCache': cuser, 'taskCache': ctask, 'modelCache': cmodel, 'fileCache': cfile, 'config': config.tornado } DSettings = copy(RSettings) DSettings['path'] = os.path.join(curdir, 'data') SSettings = copy(RSettings) SSettings['path'] = os.path.join(curdir, 'static') application = tornado.web.Application([ (r'/p/login', handler.LoginHandler, RSettings), (r'/logout', handler.LogoutHandler), (r'(/request|/auth)$', handler.CommonRequestHandler, RSettings), (r'/data/(.*?)$', handler.AuthStaticFileHandler, DSettings), (r'/site/(.*?)$', handler.AuthStaticFileHandler, SSettings), (r'/p/(.*?)$', tornado.web.StaticFileHandler, { 'path': os.path.join(curdir, 'public') }), (r'/(.*?)$', handler.DefaultRedirectHandler), ], **settings) server = tornado.httpserver.HTTPServer( application, ssl_options={ "certfile": os.path.join(curdir, "ssl/auth.crt"), "keyfile": os.path.join(curdir, "ssl/auth.key") }) port = 8888 if len(sys.argv) <= 1 else int(sys.argv[1]) server.listen(port) tornado.ioloop.PeriodicCallback(try_exit, 100).start() tornado.ioloop.IOLoop.instance().start()
run: python -m projects.dynamic_facial_expressions_ICANN.01_reproduce_ICANN_NormBase """ import numpy as np import os from utils.load_data import load_data from utils.load_config import load_config from models.NormBase import NormBase from datasets_utils.expressivity_level import segment_sequence # t0001: 2-norm t0002: 1-norm t0003: simplified t0004: direction-only t0005: expressitivity-direction # t0006: 2-norm-monkey_morph # config = load_config("norm_base_reproduce_ICANN_t0015.json", path="configs/norm_base_config") config = load_config("NB_reproduce_ICANN_m0002.json", path="configs/norm_base_config") # config["tau_u"] = 3 # config["tau_v"] = 3 config['tau_y'] = 2 # 15 config['tau_d'] = 2 # -------------------------------------------------------------------------------------------------------------------- # train model # load training data train_data = load_data(config) train_data[0] = segment_sequence(train_data[0], config['train_seq_start_idx'], config['seq_length']) train_data[1] = segment_sequence(train_data[1], config['train_seq_start_idx'], config['seq_length']) print("[LOAD] Shape train_data segmented", np.shape(train_data[0])) print("[LOAD] Shape train_label segmented", np.shape(train_data[1]))
from models.NormBase import NormBase # setting retrain = False # param, order: human, monkey, both config_names = [ "norm_base_investigate_layer_t0001.json", "norm_base_investigate_layer_t0002.json", "norm_base_investigate_layer_t0003.json" ] # load config configs = [] for config_name in config_names: configs.append(load_config(config_name)) # train models/load model norm_base_list = [] for config in configs: try: if retrain: raise IOError("retrain = True") norm_base = NormBase(config, input_shape=(224, 224, 3), save_name=config["sub_folder"]) except IOError: norm_base = NormBase(config, input_shape=(224, 224, 3)) norm_base.fit(load_data(config, train=config["train_dim_ref_tun_ref"][0]), fit_dim_red=True,
""" 2021/01/18 This script plots the network response to basic shapes and the movement of them. Look under load_data._load_basic_shapes for all the possibilities of basic shapes. """ import numpy as np import tensorflow as tf import os from plots_utils.plot_cnn_output import plot_cnn_output from utils.load_config import load_config from utils.load_data import load_data # load config config = load_config("norm_base_basic_shape_t0002.json") # make folder folder = os.path.join("../../models/saved", config["save_name"]) if not os.path.exists(folder): os.mkdir(folder) # cnn model = tf.keras.applications.VGG19(include_top=False, weights="imagenet", input_shape=(224, 224, 3)) model = tf.keras.Model(inputs=model.input, outputs=model.get_layer("block3_pool").output) # calculate and plot response images = load_data(config, train=config["subset"])