def generate(BATCH_SIZE, nice=False): generator = generator_model() generator.compile(loss="binary_crossentropy", optimizer="SGD") generator.load_weights("generator") if nice: discriminator = discriminator_model() discriminator.compile(loss="binary_entropy", optimizer="SGD") discriminator.load_weights("discriminator") noise = np.zeros((BATCH_SIZE * 20, 100)) for i in range(BATCH_SIZE * 10): noise[i, :] = np.random.uniform(-1, 1, 100) generated_images = generator.predict(noise, verbose=1) d_pret = discriminator.predict(generated_images, verbose=1) index = np.arange(0, BATCH_SIZE * 20) index.resize((BATCH_SIZE * 20, 1)) pre_with_index = list(np.append(d_pret, index, axis=1)) pre_with_index.sort(key=lambda x: x[0], reverse=True) nice_images = np.zeros((BATCH_SIZE, 1) + (generated_images.shape[2:]), dtype=np.float32) for i in range(int(BATCH_SIZE)): idx = int(pre_with_index[i][1]) nice_images[i, 0, :, :] = generated_images[idx, 0, :, :] image = combine_images(nice_images) else: noise = np.zeros((BATCH_SIZE, 100)) for i in range(BATCH_SIZE): noise[i, :] = np.random.uniform(-1, 1, 100) generated_images = generator.predict(noise, verbose=1) image = combine_images(generated_images) image = image * 127.5 + 127.5 Image.fromarray(image.astype(np.uint8)).save("generated_image.png")
def validation_generator(data: pd.DataFrame, batch_size: int, fixed_input_shape: tuple): # Create empty arrays to contain batch of features and labels# batch_features = np.zeros((batch_size, fixed_input_shape[0], fixed_input_shape[1], fixed_input_shape[2])) batch_labels = np.zeros((batch_size, 2)) # [xmin, xmax, ymin, ymax] batch_box = np.zeros((batch_size, 4)) while True: for i in range(batch_size): # choose random index in features index = random.randint(0, len(data.index) - 1) x = cv2.imread(data["filename"].iloc[index]) x = cv2.resize(x, (fixed_input_shape[1], fixed_input_shape[0])) x = np.expand_dims(x, axis=0) x = preprocess_input(x.astype(np.float64)) batch_features[i, :, :, :] = x # labels: person == [1, 0], background = [0, 1] if data['name'].iloc[index] == 'person': batch_labels[i, :] = [1, 0] elif data['name'].iloc[index] == 'background': batch_labels[i, :] = [0, 1] else: raise ValueError('Unexpected value in "name" column') batch_box[i, 0] = data["xmin"].iloc[index] batch_box[i, 1] = data["xmax"].iloc[index] batch_box[i, 2] = data["ymin"].iloc[index] batch_box[i, 3] = data["ymax"].iloc[index] yield (batch_features, [batch_labels, batch_box])
def decoder_sequence(input_seq): src_to_index, tar_to_index = [], [] index_to_src = dict((i, char) for char, i in src_to_index.items()) index_to_tar = dict((i, char) for char, i in tar_to_index.items()) model = load_model('./model/') encoder_inputs = model.input[0] # input_1 encoder_outputs, state_h_enc, state_c_enc = model.layers[ 2].output # lstm_1 encoder_states = [state_h_enc, state_c_enc] encoder_model = Model(encoder_inputs, encoder_states) states_value = encoder_model.predict(input_seq) decoder_inputs = model.input[1] # input_2 decoder_state_input_h = Input(shape=(256, ), name='input_3') decoder_state_input_c = Input(shape=(256, ), name='input_4') decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c] decoder_lstm = model.layers[3] decoder_outputs, state_h_dec, state_c_dec = decoder_lstm( decoder_inputs, initial_state=decoder_states_inputs) decoder_states = [state_h_dec, state_c_dec] decoder_dense = model.layers[4] decoder_outputs = decoder_dense(decoder_outputs) decoder_model = Model([decoder_inputs] + decoder_states_inputs, [decoder_outputs] + decoder_states) max_tar_len = decoder_inputs.shape[1] tar_vocab_size = decoder_inputs.shape[2] target_seq = np.zeros((1, 1, tar_vocab_size)) target_seq[0, 0, tar_to_index['\t']] = 1 stop_condition = False decoded_sentence = "" while not stop_condition: # stop_condition이 True가 될 때까지 루프 반복 output_tokens, h, c = decoder_model.predict([target_seq] + states_value) sampled_token_index = np.argmax(output_tokens[0, -1, :]) sampled_char = index_to_tar[sampled_token_index] decoded_sentence += sampled_char # <sos>에 도달하거나 최대 길이를 넘으면 중단. if (sampled_char == '\n' or len(decoded_sentence) > max_tar_len): stop_condition = True # 길이가 1인 타겟 시퀀스를 업데이트 합니다. target_seq = np.zeros((1, 1, tar_vocab_size)) target_seq[0, 0, sampled_token_index] = 1. # 상태를 업데이트 합니다. states_value = [h, c] return decoded_sentence
def reset_states(self, states=None): if not self.stateful: raise AttributeError('Layer must be stateful.') batch_size = self.input_spec[0].shape[0] if not batch_size: raise ValueError('If a RNN is stateful, it needs to know ' 'its batch size. Specify the batch size ' 'of your input tensors: \n' '- If using a Sequential model, ' 'specify the batch size by passing ' 'a `batch_input_shape` ' 'argument to your first layer.\n' '- If using the functional API, specify ' 'the batch size by passing a ' '`batch_shape` argument to your Input layer.') # initialize state if None if self.states[0] is None: if hasattr(self.cell.state_size, '__len__'): self.states = [K.zeros((batch_size, dim)) for dim in self.cell.state_size] else: self.states = [K.zeros((batch_size, self.cell.state_size))] elif states is None: if hasattr(self.cell.state_size, '__len__'): for state, dim in zip(self.states, self.cell.state_size): K.set_value(state, np.zeros((batch_size, dim))) else: K.set_value(self.states[0], np.zeros((batch_size, self.cell.state_size))) else: states = to_list(states, allow_tuple=True) if len(states) != len(self.states): raise ValueError('Layer ' + self.name + ' expects ' + str(len(self.states)) + ' states, ' 'but it received ' + str( len(states)) + ' state values. Input received: ' + str(states)) for index, (value, state) in enumerate(zip(states, self.states)): if hasattr(self.cell.state_size, '__len__'): dim = self.cell.state_size[index] else: dim = self.cell.state_size if value.shape != (batch_size, dim): raise ValueError('State ' + str(index) + ' is incompatible with layer ' + self.name + ': expected shape=' + str((batch_size, dim)) + ', found shape=' + str(value.shape)) # TODO: consider batch calls to `set_value`. K.set_value(state, value)
def batch_generator(self, batch_size): train = sorted(os.listdir(TRAIN_INPUT_DATA_PATH)) train_mask = sorted(os.listdir(TRAIN_OUTPUT_DATA_PATH)) print(train) print(train_mask) for file in train: x = np.zeros((batch_size, IMAGE_SIZE, IMAGE_SIZE, 3)) y = np.zeros((batch_size, IMAGE_SIZE, IMAGE_SIZE)) for i in range(batch_size): # random_image = random.randint(0, self.x.shape[0] - 1) if file.endswith(IMAGE_FORMAT): x[i] = tiff.imread(TRAIN_INPUT_DATA_PATH + file) y[i] = tiff.imread(TRAIN_OUTPUT_DATA_PATH + file) new_y = y.reshape(len(y), len(y[0]), len(y[0][0]), 1) yield x, new_y
def print_policy(self): array_1d = np.zeros(self.grid_size) tabs = 0 for i in range(0, self.grid_size): array_1d[i] = 1 sep = ' ' if not ((i + 1) % self.game.positions_space[1]): # tabs += 1 sep = '\n' print(self.model.predict(array_1d.reshape((1, -1))), end=sep) array_1d[i] = 0
def getCapsulesMatrix(state): """ Return matrix with capsule coordinates set to 1 """ width, height = state.data.layout.width, state.data.layout.height capsules = state.data.layout.capsules matrix = np.zeros((height, width), dtype=np.int8) for i in capsules: # Insert capsule cells vertically reversed into matrix matrix[-1 - i[1], i[0]] = 1 return matrix
def getWallMatrix(state): """ Return matrix with wall coordinates set to 1 """ width, height = state.data.layout.width, state.data.layout.height grid = state.data.layout.walls matrix = np.zeros((height, width), dtype=np.int8) for i in range(grid.height): for j in range(grid.width): # Put cell vertically reversed in matrix cell = 1 if grid[j][i] else 0 matrix[-1 - i][j] = cell return matrix
def getPacmanMatrix(state): """ Return matrix with pacman coordinates set to 1 """ width, height = state.data.layout.width, state.data.layout.height matrix = np.zeros((height, width), dtype=np.int8) for agentState in state.data.agentStates: if agentState.isPacman: pos = agentState.configuration.getPosition() cell = 1 matrix[-1 - int(pos[1])][int(pos[0])] = cell return matrix
def predict(self, image): image_h, image_w, _ = image.shape image = cv2.resize(image, (416, 416)) image = self.normalize(image) input_image = image[:, :, ::-1] input_image = np.expand_dims(input_image, 0) dummy_array = np.zeros((1, 1, 1, 1, self.config['model']['max_obj'], 4)) netout = self.model.predict([input_image, dummy_array])[0] boxes = decode_netout(netout, self.config['model']['anchors'], self.config['model']['nb_class']) return boxes
def get_filters_for_layer(layer_number, layer_outputs): x_max = layer_outputs[layer_number].shape[0] y_max = layer_outputs[layer_number].shape[1] n = layer_outputs[layer_number].shape[2] L = [] for i in range(n): L.append(np.zeros((x_max, y_max))) for i in range(n): for x in range(x_max): for y in range(y_max): L[i][x][y] = layer_outputs[layer_number][x][y][i] return L
def train(BATCH_SIZE): (X_train, y_train), (X_test, y_test) = mnist.load_data() X_train = (X_train.astype(np.float32) - 127.5) / 127.5 X_train = X_train.reshape((X_train.shape[0], 1) + X_train.shape[1:]) discriminator = discriminator_model() generator = generator_model() discriminator_on_generator = generator_containing_discriminator( generator, discriminator) d_optim = SGD(lr=0.0005, momentum=0.9, nesterov=True) g_optim = SGD(lr=0.0005, momentum=0.9, nesterov=True) generator.compile(loss="binary_crossentropy", optimizer=d_optim) discriminator_on_generator.compile(loss="binary_crossentropy", optimizer=g_optim) discriminator.trainable = True discriminator.compile(loss="binary_crossentropy", optimizer=d_optim) noise = np.zeros((BATCH_SIZE, 100)) for epochs in range(100): print("Epoch is", epochs) print("Number of batches", int(X_train.shape[0] / BATCH_SIZE)) for index in range(int(X_train.shape[0] / BATCH_SIZE)): for i in range(BATCH_SIZE): noise[i, :] = np.random.uniform(-1, 1, 100) image_batch = X_train[index * BATCH_SIZE:(index + 1) * BATCH_SIZE] image_batch = image_batch.reshape(image_batch.shape[0], image_batch.shape[2], image_batch.shape[3], image_batch.shape[1]) generated_images = generator.predict(noise, verbose=0) if index % 20 == 0: image = combine_images(generated_images) image = image * 127.5 + 127.5 Image.fromarray(image.astype( np.uint8)).save(str(epochs) + "_" + str(index) + ".png") X = np.concatenate((image_batch, generated_images)) y = [1] * BATCH_SIZE + [0] * BATCH_SIZE d_loss = discriminator.train_on_batch(X, y) print("batch %d d_loss : %f" % (index, d_loss)) for i in range(BATCH_SIZE): noise[i, :] = np.random.uniform(-1, 1, 100) discriminator.trainable = False g_loss = discriminator_on_generator.train_on_batch( noise, [1] * BATCH_SIZE) discriminator.trainable = True print("batch %d g_loss : %f" % (index, g_loss)) if index % 10 == 9: generator.save_weights("generator", True) discriminator.save_weights("discriminator", True)
def combine_images(generated_images): generated_images = generated_images.reshape(generated_images.shape[0], generated_images.shape[3], generated_images.shape[1], generated_images.shape[2]) num = generated_images.shape[0] width = int(math.sqrt(num)) height = int(math.ceil(float(num) / width)) shape = generated_images.shape[2:] image = np.zeros((height * shape[0], width * shape[1]), dtype=generated_images.dtype) for index, img in enumerate(generated_images): i = int(index / width) j = index % width image[i * shape[0]:(i + 1) * shape[0], j * shape[1]:(j + 1) * shape[1]] = img[0, :, :] return image
def action_to_output(self, action): ret = np.zeros(self.action_dim) for idx, move in enumerate(self.possible_actions[action]): { 0: lambda: ret[:self.action_dim // 2][ 0::3], # first half upper mussels 1: lambda: ret[:self.action_dim // 2][ 1::3], # first half transverse mussels 2: lambda: ret[:self.action_dim // 2][ 2::3], # first half downer mussels 3: lambda: ret[self.action_dim // 2:][ 0::3], # second half upper mussels 4: lambda: ret[self.action_dim // 2:][ 1::3], # second half transverse mussels 5: lambda: ret[self.action_dim // 2:][ 2::3], # second half downer mussels }.get(idx)().fill(move) return ret
def __init__(self, _, action_dim, agent_params): """Initialize agent assuming floating point state and action""" self.is_learning = agent_params.get(self.IS_LEARNING, True) self.end_point = [9, -1] self.state_dim = len(self.get_all_features2(list(np.arange(0, 82)))) self.action_dim = action_dim self.action = np.zeros(action_dim) self.gamma = 0.9 self.memory = deque(maxlen=20000) self.epsilon_start = 0.8 if not self.is_learning: self.epsilon_start = 0.0 self.epsilon = self.epsilon_start # exploration rate self.epsilon_min = 0.01 self.epsilon_decay = 0.995 self.learning_rate = 0.001 self.steps = 0 self.last_state = None self.last_action = None self.possible_actions = [ [0, 0, 0, 0, 0, 0], # do nothing [1, 0, 0, 1, 0, 0], # ∏ [0, 0, 1, 0, 0, 1], # ∐ [1, 1, 1, 0.5, 0.5, 0.5], # -- [0.5, 0, 0, 0, 0, 1], # Ƨ [0, 0, 0.5, 1, 0, 0], # S [0, 0, 1, 0, 1, 0], # ⊂_ [1, 0, 0, 0, 1, 0], # ∩_ ] self.action_size = len( self.possible_actions) # number of possible actions ZXC + IOP self.model = self._build_model() self.begin_point = [0, 0] self.dist_to_end = self.distance(self.begin_point[0], self.begin_point[1], self.end_point[0], self.end_point[1]) self.max_repeat = 10 self.repeat_count = self.max_repeat random.seed()
def prepare_state(self, state): # 2d to list array_1d = np.zeros(self.grid_size) idx = state[0] * self.game.positions_space[0] + state[1] array_1d[idx] = 1 return (array_1d.reshape((1, -1)))
def getStateMatrices(self, state): """ Return wall, ghosts, food, capsules matrices """ def getWallMatrix(state): """ Return matrix with wall coordinates set to 1 """ width, height = state.data.layout.width, state.data.layout.height grid = state.data.layout.walls matrix = np.zeros((height, width), dtype=np.int8) for i in range(grid.height): for j in range(grid.width): # Put cell vertically reversed in matrix cell = 1 if grid[j][i] else 0 matrix[-1 - i][j] = cell return matrix def getPacmanMatrix(state): """ Return matrix with pacman coordinates set to 1 """ width, height = state.data.layout.width, state.data.layout.height matrix = np.zeros((height, width), dtype=np.int8) for agentState in state.data.agentStates: if agentState.isPacman: pos = agentState.configuration.getPosition() cell = 1 matrix[-1 - int(pos[1])][int(pos[0])] = cell return matrix def getGhostMatrix(state): """ Return matrix with ghost coordinates set to 1 """ width, height = state.data.layout.width, state.data.layout.height matrix = np.zeros((height, width), dtype=np.int8) for agentState in state.data.agentStates: if not agentState.isPacman: if not agentState.scaredTimer > 0: pos = agentState.configuration.getPosition() cell = 1 matrix[-1 - int(pos[1])][int(pos[0])] = cell return matrix def getScaredGhostMatrix(state): """ Return matrix with ghost coordinates set to 1 """ width, height = state.data.layout.width, state.data.layout.height matrix = np.zeros((height, width), dtype=np.int8) for agentState in state.data.agentStates: if not agentState.isPacman: if agentState.scaredTimer > 0: pos = agentState.configuration.getPosition() cell = 1 matrix[-1 - int(pos[1])][int(pos[0])] = cell return matrix def getFoodMatrix(state): """ Return matrix with food coordinates set to 1 """ width, height = state.data.layout.width, state.data.layout.height grid = state.data.food matrix = np.zeros((height, width), dtype=np.int8) for i in range(grid.height): for j in range(grid.width): # Put cell vertically reversed in matrix cell = 1 if grid[j][i] else 0 matrix[-1 - i][j] = cell return matrix def getCapsulesMatrix(state): """ Return matrix with capsule coordinates set to 1 """ width, height = state.data.layout.width, state.data.layout.height capsules = state.data.layout.capsules matrix = np.zeros((height, width), dtype=np.int8) for i in capsules: # Insert capsule cells vertically reversed into matrix matrix[-1 - i[1], i[0]] = 1 return matrix # Create observation matrix as a combination of # wall, pacman, ghost, food and capsule matrices # width, height = state.data.layout.width, state.data.layout.height width, height = state.data.layout.width, state.data.layout.height observation = np.zeros((6, height, width)) observation[0] = getWallMatrix(state) observation[1] = getPacmanMatrix(state) observation[2] = getGhostMatrix(state) observation[3] = getScaredGhostMatrix(state) observation[4] = getFoodMatrix(state) observation[5] = getCapsulesMatrix(state) #print 'observation: ', observation #observation = np.swapaxes(observation, 0, 2) #print 'observation: ', observation return observation
def evaluate(self, generator, iou_threshold=0.3, score_threshold=0.3, max_detections=100, save_path=None): """ Evaluate a given dataset using a given model. code originally from https://github.com/fizyr/keras-retinanet # Arguments generator : The generator that represents the dataset to evaluate. model : The model to evaluate. iou_threshold : The threshold used to consider when a detection is positive or negative. score_threshold : The score confidence threshold to use for detections. max_detections : The maximum number of detections to use per image. save_path : The path to save images with visualized detections to. # Returns A dict mapping class names to mAP scores. """ # gather all detections and annotations all_detections = [[None for i in range(generator.num_classes())] for j in range(generator.size())] all_annotations = [[None for i in range(generator.num_classes())] for j in range(generator.size())] for i in range(generator.size()): raw_image = generator.load_image(i) raw_height, raw_width, raw_channels = raw_image.shape # make the boxes and the labels pred_boxes = self.predict(raw_image) score = np.array([box.score for box in pred_boxes]) pred_labels = np.array([box.label for box in pred_boxes]) if len(pred_boxes) > 0: pred_boxes = np.array([[box.xmin * raw_width, box.ymin * raw_height, box.xmax * raw_width, box.ymax * raw_height, box.score] for box in pred_boxes]) else: pred_boxes = np.array([[]]) # sort the boxes and the labels according to scores score_sort = np.argsort(-score) pred_labels = pred_labels[score_sort] pred_boxes = pred_boxes[score_sort] # copy detections to all_detections for label in range(generator.num_classes()): all_detections[i][label] = pred_boxes[pred_labels == label, :] annotations = generator.load_annotation(i) # copy detections to all_annotations for label in range(generator.num_classes()): all_annotations[i][label] = annotations[annotations[:, 4] == label, :4].copy() # compute mAP by comparing all detections and all annotations average_precisions = {} for label in range(generator.num_classes()): false_positives = np.zeros((0,)) true_positives = np.zeros((0,)) scores = np.zeros((0,)) num_annotations = 0.0 for i in range(generator.size()): detections = all_detections[i][label] annotations = all_annotations[i][label] num_annotations += annotations.shape[0] detected_annotations = [] for d in detections: scores = np.append(scores, d[4]) if annotations.shape[0] == 0: false_positives = np.append(false_positives, 1) true_positives = np.append(true_positives, 0) continue overlaps = compute_overlap(np.expand_dims(d, axis=0), annotations) assigned_annotation = np.argmax(overlaps, axis=1) max_overlap = overlaps[0, assigned_annotation] if max_overlap >= iou_threshold and assigned_annotation not in detected_annotations: false_positives = np.append(false_positives, 0) true_positives = np.append(true_positives, 1) detected_annotations.append(assigned_annotation) else: false_positives = np.append(false_positives, 1) true_positives = np.append(true_positives, 0) # no annotations -> AP for this class is 0 (is this correct?) if num_annotations == 0: average_precisions[label] = 0 continue # sort by score indices = np.argsort(-scores) false_positives = false_positives[indices] true_positives = true_positives[indices] # compute false positives and true positives false_positives = np.cumsum(false_positives) true_positives = np.cumsum(true_positives) # compute recall and precision recall = true_positives / num_annotations precision = true_positives / np.maximum(true_positives + false_positives, np.finfo(np.float64).eps) # compute average precision average_precision = compute_ap(recall, precision) average_precisions[label] = average_precision return average_precisions
def train_agent(self, enforce_play=False, save_every=100000, total_episodes=100000): env = NeuralNetPokerEnv(self.nc) neural_npc = NeuralNetworkNPC() # exploration vs exploitation eps = 0.5 # future reward factor gamma = 0.5 all_rewards = [0, 0] for i in range(1, total_episodes + 1): s = env.reset(self.nc, rand_bank_dist=True) # saving the model for keras and saving q-table like results in readable format if save_every and (i % save_every == 0 or i == 1): print("Episode {} of {}".format(i, total_episodes)) save_poker_model(self.model, all_rewards) # episode flags done = False post_river = False # iterations over single episode while not done: # getting player objects from state, either after reset of environment or next step player1 = s[0] player2 = s[1] # separating the player hand to hole and community cards # hole cards - player's unique cards # community cards - mutual cards for players hole_cards1 = player1.hand.cards[0:2] hole_cards2 = player2.hand.cards[0:2] community_cards = player1.hand.cards[2:] # state encoding to consumable format for neural network state1, _ = encode_to_vector(hole_cards1, community_cards, 0, player1.bank, self.nc) state2, _ = encode_to_vector(hole_cards2, community_cards, 0, player2.bank, self.nc) # choosing the action via epsilon exploration vs exploitation a1 = self.epsilon_choice_action(eps, neural_npc, player1, post_river) a2 = self.epsilon_choice_action(eps, neural_npc, player2, post_river) # checking whether the state action is to be enforced if enforce_play or post_river: a1, a2 = 1, 1 # moving to next in accordance to action and states new_s, r, done, _ = env.step([a1, a2]) # reward for both players reward1 = r[0] reward2 = r[1] all_rewards[0] += reward1 + reward2 all_rewards[1] += 2 # predicted future reward next_reward1 = np.zeros((2, )) next_reward2 = np.zeros((2, )) if new_s: # separating the player hand to hole and community cards # hole cards - player's unique cards # community cards - mutual cards for players hole_cards1 = new_s[0].hand.cards[0:2] hole_cards2 = new_s[1].hand.cards[0:2] community_cards = player1.hand.cards[2:] # encoding and predicting future reward next_state1, _ = encode_to_vector(hole_cards1, community_cards, 0, player1.bank, self.nc) next_state2, _ = encode_to_vector(hole_cards2, community_cards, 0, player2.bank, self.nc) next_reward1[1] = self.model.predict(next_state1)[0, 1] next_reward2[1] = self.model.predict(next_state2)[0, 1] # deep-q learning combining immediate and future reward target1 = reward1 + gamma * next_reward1[a1] target2 = reward2 + gamma * next_reward2[a2] # in case of future reward - only call is relevant target_vec1 = np.zeros(( 1, 2, )) target_vec2 = np.zeros(( 1, 2, )) target_vec1[0, a1] = target1 target_vec2[0, a2] = target2 # fitting the model to combined reward self.model.fit(state1, target_vec1, epochs=1, verbose=0) if a1: # takes place only if SB called self.model.fit(state2, target_vec2, epochs=1, verbose=0) # advancing to next step s = new_s
model.add(Dense(512)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(nb_classes)) model.add(Activation('softmax')) # let's train the model using SGD + momentum (how original). sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy']) model.summary() model.load_weights('weights.hdf5') # Let us just apply the method to a single image and see what are the results img = plt.imread('trial_image.jpeg').transpose((2, 0, 1)) channels, rows, cols = img.shape enlarged = np.lib.pad(img, ((0, 0), (16, 16), (16, 16)), mode='mean') # print (enlarged.shape) heat_map = np.zeros((rows, cols)) t1 = time.clock() for r in np.arange(rows - 32): for c in np.arange(cols - 32): temp = np.expand_dims(enlarged[:, r:r + 32, c:c + 32], axis=0) heat_map[r, c] = model.predict(temp)[0] print("Time taken for one image: ", time.clock() - t1)