def detect(im, param_vals):
"""
Detect number plates in an image.
:param im:
Image to detect number plates in.
:param param_vals:
Model parameters to use. These are the parameters output by the `train`
module.
:returns:
Iterable of `bbox_tl, bbox_br, letter_probs`, defining the bounding box
top-left and bottom-right corners respectively, and a 7,36 matrix
giving the probability distributions of each letter.
"""
# Convert the image to various scales.
scaled_ims = list(make_scaled_ims(im, model.WINDOW_SHAPE))
# Load the model which detects number plates over a sliding window.
x, y, params = model.get_detect_model()
# Execute the model at each scale.
with tf.Session(config=tf.ConfigProto()) as sess:
y_vals = []
for scaled_im in scaled_ims:
feed_dict = {x: numpy.stack([scaled_im])}
feed_dict.update(dict(zip(params, param_vals)))
y_vals.append(sess.run(y, feed_dict=feed_dict))
# Interpret the results in terms of bounding boxes in the input image.
# Do this by identifying windows (at all scales) where the model predicts a
# number plate has a greater than 50% probability of appearing.
#
# To obtain pixel coordinates, the window coordinates are scaled according
# to the stride size, and pixel coordinates.
for i, (scaled_im, y_val) in enumerate(zip(scaled_ims, y_vals)):
for window_coords in numpy.argwhere(y_val[0, :, :, 0] >
-math.log(1./0.99 - 1)):
letter_probs = (y_val[0,
window_coords[0],
window_coords[1], 1:].reshape(
7, len(common.CHARS)))
letter_probs = common.softmax(letter_probs)
img_scale = float(im.shape[0]) / scaled_im.shape[0]
bbox_tl = window_coords * (8, 4) * img_scale
bbox_size = numpy.array(model.WINDOW_SHAPE) * img_scale
present_prob = common.sigmoid(
y_val[0, window_coords[0], window_coords[1], 0])
yield bbox_tl, bbox_tl + bbox_size, present_prob, letter_probs
def forward_progation(w):
a = np.dot(x, w)
y = softmax(a)
return y
def loss(self, x, t):
y = softmax(self.predict(x))
return crossEntropyError(y, t)
checkpoint = tf.train.Checkpoint(model=Model)
checkpoint.restore(tf.train.latest_checkpoint(string))
#Set a grid
grid = np.meshgrid(np.arange(config.cellule_x, dtype=np.float32),
np.arange(config.cellule_y, dtype=np.float32))
grid = np.expand_dims(np.stack(grid, axis=-1), axis=2)
grid = np.tile(grid, (1, 1, config.nbr_boxes, 1))
for i in range(len(images)):
img = common.prepare_image(images[i], labels[i], False)
img2 = images[i].copy()
predictions = Model(np.array([images[i]]))
pred_boxes = predictions[0, :, :, :, 0:4]
pred_conf = common.sigmoid(predictions[0, :, :, :, 4])
pred_classes = common.softmax(predictions[0, :, :, :, 5:])
ids = np.argmax(pred_classes, axis=-1)
x_center = ((grid[:, :, :, 0] + common.sigmoid(pred_boxes[:, :, :, 0])) *
config.r_x)
y_center = ((grid[:, :, :, 1] + common.sigmoid(pred_boxes[:, :, :, 1])) *
config.r_y)
w = (np.exp(pred_boxes[:, :, :, 2]) * config.anchors[:, 0] * config.r_x)
h = (np.exp(pred_boxes[:, :, :, 3]) * config.anchors[:, 1] * config.r_y)
x_min = (x_center - w / 2).astype(np.int32)
y_min = (y_center - h / 2).astype(np.int32)
x_max = (x_center + w / 2).astype(np.int32)
y_max = (y_center + h / 2).astype(np.int32)
for y in range(config.cellule_y):
def detect(im, param_vals):
"""
Detect all bounding boxes of number plates in an image.
:param im:
Image to detect number plates in.
:param param_vals:
Model parameters to use. These are the parameters output by the `train`
module.
:returns:
Iterable of `bbox_tl, bbox_br, letter_probs`, defining the bounding box
top-left and bottom-right corners respectively, and a 7,36 matrix
giving the probability distributions of each letter.
"""
# Convert the image to various scales.
scaled_ims = list(make_scaled_ims(im, model.WINDOW_SHAPE))
# Load the model which detects number plates over a sliding window.
x, y, params = model.get_detect_model()
# Execute the model at each scale.
with tf.Session(config=tf.ConfigProto()) as sess:
y_vals = []
for scaled_im in scaled_ims:
feed_dict = {x: numpy.stack([scaled_im])}
feed_dict.update(dict(zip(params, param_vals)))
y_vals.append(sess.run(y, feed_dict=feed_dict))
#plt.imshow(scaled_im)
#plt.show()
writer = tf.summary.FileWriter("logs/", sess.graph)
# Interpret the results in terms of bounding boxes in the input image.
# Do this by identifying windows (at all scales) where the model predicts a
# number plate has a greater than 50% probability of appearing.
#
# To obtain pixel coordinates, the window coordinates are scaled according
# to the stride size, and pixel coordinates.
count_detect = 0
for i, (scaled_im, y_val) in enumerate(zip(scaled_ims, y_vals)):
for window_coords in numpy.argwhere(y_val[0, :, :, 0] >
-math.log(1. / 0.99 - 1)):
letter_probs = (y_val[0,
window_coords[0],
window_coords[1], 1:].reshape(
7, len(common.CHARS)))
letter_probs = common.softmax(letter_probs)
img_scale = float(im.shape[0]) / scaled_im.shape[0]
bbox_tl = window_coords * (8, 4) * img_scale
bbox_size = numpy.array(model.WINDOW_SHAPE) * img_scale
present_prob = common.sigmoid(
y_val[0, window_coords[0], window_coords[1], 0])
count_detect += 1
yield bbox_tl, bbox_tl + bbox_size, present_prob, letter_probs
print("count detect:", count_detect)
print("show return window: ", bbox_tl, "return windows box: ", bbox_tl + bbox_size)
print("present: ", present_prob)
print("letter: ", letter_probs_to_code(letter_probs))
def loss(w):
a = np.dot(x, w)
y = softmax(a) # softmax(x @ w)
e = cross_entropy_error(y, t)
return e
def detect(im, param_vals):
"""
Detect number plates in an image.
:param im:
Image to detect number plates in.
:param param_vals:
Model parameters to use. These are the parameters output by the `train`
module.
:returns:
Iterable of `bbox_tl, bbox_br, letter_probs`, defining the bounding box
top-left and bottom-right corners respectively, and a 7,36 matrix
giving the probability distributions of each letter.
"""
# Convert the image to various scales.
scaled_ims = list(make_scaled_ims(im,
model.WINDOW_SHAPE)) # 针对需检测图片产生迭代缩放图片列表
# Load the model which detects number plates over a sliding window.
x, y, params = model.get_detect_model() # 获取检测网络(5个卷积层)的输入,输出以及所有参数
# Execute the model at each scale.
with tf.Session(config=tf.ConfigProto()) as sess: # 建立会话
y_vals = []
for scaled_im in scaled_ims: # 遍历缩放图片列表
feed_dict = {x: numpy.stack([scaled_im])} # 建立字典feed_dict{输入：缩放图片}
feed_dict.update(dict(zip(
params,
param_vals))) # 将字典{参数：参数值}更新到字典feed_dict中->{输入：缩放图片, 参数：参数值}
y_vals.append(sess.run(y,
feed_dict=feed_dict)) # 提供检测图片和网络参数值,执行检测操作
# Interpret the results in terms of bounding boxes in the input image.
# Do this by identifying windows (at all scales) where the model predicts a
# number plate has a greater than 50% probability of appearing.
#
# To obtain pixel coordinates, the window coordinates are scaled according
# to the stride size, and pixel coordinates.
for i, (scaled_im,
y_val) in enumerate(zip(scaled_ims,
y_vals)): # 枚举元组(缩放图片, 检测输出)及对应下标
for window_coords in numpy.argwhere(
y_val[0, :, :, 0] > -math.log(1. / 0.99 - 1)
): # 对应sigmoid输出号码牌存在概率大于0.99的下标
letter_probs = (y_val[0, window_coords[0], window_coords[1],
1:].reshape(7, len(common.CHARS)))
letter_probs = common.softmax(letter_probs) # 车牌号识别正确的概率分布
img_scale = float(im.shape[0]) / scaled_im.shape[0] # 缩放比例
bbox_tl = window_coords * (
8, 4) * img_scale # 计算缩放图片上号码牌的boudingbox的左上角坐标
bbox_size = numpy.array(
model.WINDOW_SHAPE) * img_scale # 号码牌的boudingbox的尺寸
present_prob = common.sigmoid(y_val[0, window_coords[0],
window_coords[1],
0]) # 号码牌是否存在的概率分布
yield bbox_tl, bbox_tl + bbox_size, present_prob, letter_probs # 返回号码牌boudingbox的左上角坐标,右下角坐标,
hit = 0
xlen = len(test_x)
batch_size = 100
for idx, batch_sidx in enumerate(range(0, xlen, batch_size)):
print(idx + 1, batch_sidx)
batch_x = test_x[batch_sidx:batch_sidx + batch_size]
a1 = np.dot(batch_x, w1) + b1
z1 = sigmoid(a1)
a2 = np.dot(z1, w2) + b2
z2 = sigmoid(a2)
a3 = np.dot(z2, w3) + b3
batch_y = softmax(a3)
batch_predict = np.argmax(batch_y, axis=1)
# print(batch_predict.shape)
batch_t = test_t[batch_sidx:batch_sidx + batch_size]
# print(batch_t)
batch_hit = np.sum(batch_predict == batch_t)
hit += batch_hit
print(f'batch #{idx+1}, batch_hit: {batch_hit}, total hit: {hit}')
# 정확도(Accuracy)
print(f'Accuracy: {hit/xlen}')
print(f'a2 = {a2}') # 100 vector
print('\n== 신호전달 구현4: 은닉 2층 활성함수 h() 적용 ============================')
print(f'a2 dimension: {a2.shape}') # 100 vector
z2 = sigmoid(a2)
print(f'z2 = {z2}')
print('\n== 신호전달 구현5: 출력층 전달 ============================')
print(f'z2 dimension: {z2.shape}') # 100 vector
w3 = network['W3']
print(f'w3 dimension: {w3.shape}') # 100 x 10 matrix
b3 = network['b3']
print(f'b3 dimension: {b3.shape}') # 10 vector
a3 = np.dot(z2, w3) + b3
print(f'a3 = {a3}')
print('\n== 신호전달 구현6: 출력층 활성함수 σ() 적용 =======================')
print(f'a3 dimension: {a3.shape}') # 10 vector
y = softmax(a3) # 10 vector, index = 0~9는 각각 이미지가 0일 확률, 1일 확률 등을 나타낸다.
print(f'y = {y}') # y의 10개 데이터의 합은 1이다.
print('\n== 예측 결과 ======================================')
predict = np.argmax(
y) # 최댓값의 index를 반환한다. np.argmax(y, axis = 0)은 배열의 경우 0열끼리, 1열끼리 한줄씩 비교한다.
print(f'{randidx+1} 번째 이미지 예측: {predict}')
print('\n== 정답 ======================================')
t = test_t[randidx]
print(f'{randidx+1} 번째 이미지 레이블: {t}') # 실제 들어있는 데이터의 숫자
# 출력함수(출력층 활성함수) σ() - 소프트맥스함수(softmax Function)
import os
import sys
import numpy as np
from pathlib import Path
try:
sys.path.append(os.path.join(Path(os.getcwd()).parent, 'lib'))
from common import softmax, softmax_overflow
except ImportError:
print('Library Module Can Not Found')
# test1
a = np.array([0.3, 1., 0.78])
y = softmax(a)
print(y, np.sum(y))
# # test2 큰값: 800.
# a = np.array([0.3, 800., 0.78])
# y = softmax_overflow(a)
# print(y)
# test2: 큰값: 800.
a = np.array([0.3, 800., 0.78])
y = softmax(a)
print(y, np.sum(y))
def loss(self, x, t):
z = self.predict(x)
y = softmax(z)
loss = cross_entropy_error(y, t)
return loss
def loss(w, x, t):
a = np.dot(x, w)
y = softmax(a)
e = cross_entropy_error(y, t)
return e
def calcul_map(model, dataset, beta=1., seuil=0.5):
seuil_depasse = 0
grid = np.meshgrid(np.arange(config.cellule_x, dtype=np.float32),
np.arange(config.cellule_y, dtype=np.float32))
grid = np.expand_dims(np.stack(grid, axis=-1), axis=2)
grid = np.tile(grid, (1, 1, 1, config.nbr_boxes, 1))
index_labels2 = 0
labels2_ = labels2 * [
config.r_x, config.r_y, config.r_x, config.r_y, 1, 1, 1
]
score = []
tab_nbr_reponse = []
tab_tp = []
tab_true_boxes = []
for images, labels in dataset:
predictions = np.array(model(images))
pred_conf = common.sigmoid(predictions[:, :, :, :, 4])
pred_classes = common.softmax(predictions[:, :, :, :, 5:])
pred_ids = np.argmax(pred_classes, axis=-1)
x_center = ((grid[:, :, :, :, 0] +
common.sigmoid(predictions[:, :, :, :, 0])) * config.r_x)
y_center = ((grid[:, :, :, :, 1] +
common.sigmoid(predictions[:, :, :, :, 1])) * config.r_y)
w = (np.exp(predictions[:, :, :, :, 2]) * config.anchors[:, 0] *
config.r_x)
h = (np.exp(predictions[:, :, :, :, 3]) * config.anchors[:, 1] *
config.r_y)
x_min = x_center - w / 2
y_min = y_center - h / 2
x_max = x_center + w / 2
y_max = y_center + h / 2
tab_boxes = np.stack([y_min, x_min, y_max, x_max],
axis=-1).astype(np.float32)
tab_boxes = tab_boxes.reshape(
-1, config.cellule_y * config.cellule_x * config.nbr_boxes, 4)
pred_conf = pred_conf.reshape(
-1, config.cellule_y * config.cellule_x * config.nbr_boxes)
pred_ids = pred_ids.reshape(
-1, config.cellule_y * config.cellule_x * config.nbr_boxes)
for p in range(len(predictions)):
nbr_reponse = np.zeros(config.nbr_classes)
tp = np.zeros(config.nbr_classes)
nbr_true_boxes = np.zeros(config.nbr_classes)
tab_index = tf.image.non_max_suppression(tab_boxes[p],
pred_conf[p], 100)
for id in tab_index:
if pred_conf[p, id] > 0.10:
nbr_reponse[pred_ids[p, id]] += 1
for box in labels2_[index_labels2]:
if not box[5]:
break
b1 = [
tab_boxes[p, id, 1], tab_boxes[p, id, 0],
tab_boxes[p, id, 3], tab_boxes[p, id, 2]
]
iou = common.intersection_over_union(b1, box)
if iou > seuil and box[6] == pred_ids[p, id]:
tp[pred_ids[p, id]] += 1
seuil_depasse += 1
for box in labels2[index_labels2]:
if not box[5]:
break
nbr_true_boxes[int(box[6])] += 1
tab_nbr_reponse.append(nbr_reponse)
tab_tp.append(tp)
tab_true_boxes.append(nbr_true_boxes)
index_labels2 = index_labels2 + 1
tab_nbr_reponse = np.array(tab_nbr_reponse)
tab_tp = np.array(tab_tp)
tab_true_boxes = np.array(tab_true_boxes)
########################
precision_globule_rouge = tab_tp[:, 1] / (tab_nbr_reponse[:, 1] + 1E-7)
precision_trophozoite = tab_tp[:, 4] / (tab_nbr_reponse[:, 4] + 1E-7)
rappel_globule_rouge = tab_tp[:, 1] / (tab_true_boxes[:, 1] + 1E-7)
rappel_trophozoite = tab_tp[:, 4] / (tab_true_boxes[:, 4] + 1E-7)
print(
"F1 score globule rouge",
np.mean(2 * precision_globule_rouge * rappel_globule_rouge /
(precision_globule_rouge + rappel_globule_rouge + 1E-7)))
print(
"F1 score trophozoite",
np.mean(2 * precision_trophozoite * rappel_trophozoite /
(precision_trophozoite + rappel_trophozoite + 1E-7)))
precision = (precision_globule_rouge + precision_trophozoite) / 2
rappel = (rappel_globule_rouge + rappel_trophozoite) / 2
score = np.mean((1 + beta * beta) * precision * rappel /
(beta * beta * precision + rappel + 1E-7))
print("SCORE (globule rouge/trophozoite)", score)
########################
precision = tab_tp / (tab_nbr_reponse + 1E-7)
rappel = tab_tp / (tab_true_boxes + 1E-7)
score = np.mean((1 + beta * beta) * precision * rappel /
(beta * beta * precision + rappel + 1E-7))
return score, seuil_depasse
def forward(self, x, t):
self.t = t
self.y = softmax(x)
self.loss = cross_entropy_error(self.y, self.t)
return self.loss
def forward_propagation(x):
y = softmax(x)
return y
def forward(self, a, t):
self.y = co.softmax(a)
self.t = t
self.loss = co.cross_entropy_error(self.y, self.t)
return self.loss
z2 = sigmoid(a2)
print(f'z2 = {z2}')
print('\n== 신호전달 구현5: 출력층 전달 ============================')
print(f'z2 dimension: {z2.shape}') # 100 vector
w3 = network['W3']
print(f'w3 dimension: {w3.shape}') # 100 x 10 matrix
b3 = network['b3']
print(f'b3 dimension: {b3.shape}') # 10 vector
a3 = np.dot(z2, w3) + b3
print(f'a3 = {a3}')
print('\n== 신호전달 구현6: 출력층 활성함수 σ() 적용 =======================')
print(f'a3 dimension: {a3.shape}') # 10 vector
y = softmax(a3)
print(f'y = {y}')
print('\n== 예측 결과 ======================================')
predict = np.argmax(y)
print(f'{randidx+1} 번재 이미지 예측: {predict}')
print('\n== 정답 ======================================')
t = test_t[randidx]
print(f'{randidx+1} 번재 이미지 레이블: {t}')
xlen = len(test_x) # 10000
batch_size = 100
for idx, batch_sidx in enumerate(range(
0, xlen, batch_size)): # 1부터 10000까지의 데이터를 100개 단위로 나누어 연산.
batch_x = test_x[batch_sidx:batch_sidx +
batch_size] # 0~99 / 100~199 등등 # (100, 784) tensor 2
a1 = np.dot(batch_x, w1) + b1 # (100, 784) * (784 * 50) = (100 * 50)
z1 = sigmoid(a1) # 은닉층 활성 함수
a2 = np.dot(z1, w2) + b2 # (100 * 50) * (50 * 100) = (100 * 100)
# b2는 100 vector이지만 Broadcasting되어 100행으로 늘어나 더해진다.
z2 = sigmoid(a2) # 은닉층 활성 함수
a3 = np.dot(z2, w3) + b3 # (100 * 100) * (100 * 10) = (100 * 10)
batch_y = softmax(a3) # 출력층 활성 함수
batch_predict = np.argmax(batch_y, axis=1)
# batch_y (100 * 10) matrix는 100개의 데이터가 10개의 열을 가지는데 10개의 열의 합은 1이다.
# 또 각각의 index는 이미지가 나타내는 숫자를 의미하고 데이터 값은 그 숫자일 확률을 의미한다.
# 고로 각 행의 최댓값의 index를 반환하는 argmax()를 이용하면 예측한 값을 알 수 있다.
batch_t = test_t[batch_sidx:batch_sidx + batch_size]
batch_hit = np.sum(batch_predict == batch_t)
# 'batch_predict == batch_t'를 출력하면 True / False 값이 반환되고
# 이를 np.sum()해주면 batch 안의 데이터 중 올바르게 예측한 숫자를 알 수 있다.
hit += batch_hit
print(f'batch #{idx+1}, batch hit: {batch_hit}, total hit:{hit}')
# 정확도(Accuracy)
