def execute(self):
input_memory = self.dependencies[0].output_memory
in_H = input_memory.shape[2]
in_W = input_memory.shape[3]
input_data = input_memory.get_data()
if len(input_memory.shape) != 4:
ErrorHandler.raise_error(self.id, " input memory needs to 4 dim!")
out_N, out_C, out_H, out_W = self.calc_output_shape(input_memory.shape)
self.output_memory = MemoryImpl((out_N, out_C, out_H, out_W))
out_data = self.output_memory.get_original_data()
for N in range(out_N):
for C in range(out_C):
for H in range(out_H):
for W in range(out_W):
inp_idx_h = H * self.stride[0]
inp_idx_w = W * self.stride[1]
values = []
for i in range(self.pooling_shape[0]):
if inp_idx_h + i < in_H:
for j in range(self.pooling_shape[1]):
if inp_idx_w + j < in_W:
values.append(
input_data[N][C][inp_idx_h +
i][inp_idx_w + j])
out_data[N][C][H][W] = self.do_pooling(values)
def __init__(self, id, input, pooling_shape, pooling_type, stride=None):
ErrorHandler.is_type_generic(pooling_shape, tuple)
ErrorHandler.is_type_generic(pooling_type, PoolingType)
super().__init__(id, [input])
self.pooling_shape = pooling_shape
self.pooling_type = pooling_type
self.stride = stride
def do_activation(self, value):
if self.activation_func == ActivationFunctions.RELU:
return max(0, value)
elif self.activation_func == ActivationFunctions.NONE:
return value
else:
ErrorHandler.raise_error("[ERROR] Activation function for: " +
self.id + " not implemented.")
def fill_data(self, new_data):
copied_data = new_data
if isinstance(copied_data, list):
copied_data = np.asarray(new_data, dtype=float)
else:
ErrorHandler.is_type_generic(copied_data, np.ndarray)
ErrorHandler.is_equal(self.shape, copied_data.shape)
self.__data = copied_data
def calc_output_shape(self, input_shape):
ErrorHandler.is_type_generic(input_shape, tuple)
nout = input_shape[0]
cout = input_shape[1]
hout = int((input_shape[2] -
(self.pooling_shape[0] - 1) - 1) / self.stride[0] + 1)
wout = int((input_shape[3] -
(self.pooling_shape[1] - 1) - 1) / self.stride[1] + 1)
return (nout, cout, hout, wout)
def make_connections(self):
for node_id, node in self.nodes_map.items():
input_ids = node.primitive.inputs
if len(input_ids) != 0:
for inp_id in input_ids:
if self.nodes_map.get(inp_id) is None:
ErrorHandler.raise_error("There is no " + str(inp_id) +
", which is input to: " +
str(node_id))
node.dependencies.append(self.nodes_map[inp_id])
self.nodes_map[inp_id].users.append(node)
def __init__(self, primitives, dump_graph):
ErrorHandler.is_list(primitives)
self.graph = graph.Graph()
# [1] Create nodes.
self.__create_nodes(primitives)
# [2] Connect nodes.
self.graph.make_connections()
# [3] Mark inputs and outputs nodes
self.graph.set_inputs_and_outputs()
# [4] Calc DFS (execution order)
self.graph.calc_dfs()
if dump_graph is True:
self.__dump_graph()
def execute(self):
input_memory = self.dependencies[0].output_memory
if len(input_memory.shape) != 4:
ErrorHandler.raise_error(self.id, " input memory needs to 4 dim!")
inp_data = input_memory.get_original_data()
output_shape = input_memory.get_shape()
self.output_memory = MemoryImpl(output_shape)
out_data = self.output_memory.get_original_data()
for N in range(input_memory.shape[0]):
sum_batch = np.sum(np.exp(inp_data[N]))
for C in range(input_memory.shape[1]):
for H in range(input_memory.shape[2]):
for W in range(input_memory.shape[3]):
out_data[N][C][H][W] = np.exp(inp_data[N][C][H][W]) / sum_batch
if self.do_log:
out_data[N][C][H][W] = np.log(out_data[N][C][H][W])
pass
def calc_output_shape(self):
batch = self.input(0).output_memory.shape[0]
in_wh = self.input(0).output_memory.shape[2]
out_ch = self.input(1).output_memory.shape[0]
kernel_size = self.input(1).output_memory.shape[2]
if self.input(0).output_memory.shape[2] != self.input(
0).output_memory.shape[3]:
ErrorHandler.raise_error(
"Currently unsymetric input size is not supported.")
if self.input(1).output_memory.shape[2] != self.input(
1).output_memory.shape[3]:
ErrorHandler.raise_error(
"Currently unsymetric kernel size is not supported.")
if self.input(0).output_memory.shape[1] != self.input(
1).output_memory.shape[1]:
ErrorHandler.raise_error(
"Diffrent size of features for input and weights!")
hw_out = (in_wh - kernel_size) + 1
return batch, out_ch, hw_out, hw_out
def __init__(self, id, input, new_shape):
ErrorHandler.is_type_generic(new_shape, tuple)
super().__init__(id, [input])
self.new_shape = new_shape
def __init__(self, id, memory):
ErrorHandler.is_type_generic(memory, Memory)
super().__init__(id, [])
self.memory = memory
def __init__(self, id, input, weights_id, bias_id):
ErrorHandler.is_string(weights_id)
ErrorHandler.is_string(bias_id)
super().__init__(id, [input, weights_id, bias_id])
def __init__(self, id, inputs):
ErrorHandler.is_string(id)
ErrorHandler.is_list(inputs)
self.id = id
self.inputs = inputs
def execute(self):
ErrorHandler.raise_error("[ERROR] Execute not implemented for: " +
self.id + "!!!")
def input(self, idx=0):
if idx > len(self.dependencies) - 1:
ErrorHandler.raise_error("No input with index: ", idx)
return self.dependencies[idx]
def do_pooling(self, values):
if self.pooling_type == PoolingType.MAX:
return max(values)
else:
ErrorHandler.raise_error("[ERROR] Pooling type for: " + self.id +
" not implemented.")
def __init__(self, id, input, activation_function):
ErrorHandler.is_type_generic(activation_function, ActivationFunctions)
super().__init__(id, [input])
self.activation = activation_function
def add_node(self, node):
ErrorHandler.is_type_generic(node, Node)
if node.id in self.nodes_map:
ErrorHandler.raise_error(node.id + "is already in nodes_map!!!")
self.nodes_map[node.id] = node
def __init__(self, id, inputs, axis=0):
ErrorHandler.is_list(inputs)
ErrorHandler.is_type_generic(axis, int)
super().__init__(id, inputs)
self.axis = axis
def __init__(self, shape):
ErrorHandler.is_type_generic(shape, tuple)
self.shape = shape
self.__data = np.empty(shape)