def bbox_transform_inv(boxes, deltas):
if boxes.shape[0] == 0:
return xp.zeros((0, deltas.shape[1]), dtype=deltas.dtype)
boxes = boxes.astype(deltas.dtype, copy=False)
widths = boxes[:, 2] - boxes[:, 0] + 1.0
heights = boxes[:, 3] - boxes[:, 1] + 1.0
ctr_x = boxes[:, 0] + 0.5 * widths
ctr_y = boxes[:, 1] + 0.5 * heights
dx = deltas[:, 0::4]
dy = deltas[:, 1::4]
dw = deltas[:, 2::4]
dh = deltas[:, 3::4]
pred_ctr_x = dx * widths[:, xp.newaxis] + ctr_x[:, xp.newaxis]
pred_ctr_y = dy * heights[:, xp.newaxis] + ctr_y[:, xp.newaxis]
pred_w = xp.exp(dw) * widths[:, xp.newaxis]
pred_h = xp.exp(dh) * heights[:, xp.newaxis]
pred_boxes = xp.zeros(deltas.shape, dtype=deltas.dtype)
# x1
pred_boxes[:, 0::4] = pred_ctr_x - 0.5 * pred_w
# y1
pred_boxes[:, 1::4] = pred_ctr_y - 0.5 * pred_h
# x2
pred_boxes[:, 2::4] = pred_ctr_x + 0.5 * pred_w
# y2
pred_boxes[:, 3::4] = pred_ctr_y + 0.5 * pred_h
return pred_boxes
def test_gpu(self):
x = Variable(
cp.zeros((1, 512, self.feat_h, self.feat_w), dtype=cp.float32))
self.rpn.train = False
self.rpn.to_gpu(0)
st = time.time()
self.rpn(x, self.img_info)
print(time.time() - st, 'sec')
def concat(self, z, y=None, ncls=10):
bs = z.shape[0]
if y is None:
if self.device:
y_ = cuda.to_gpu(
cp.zeros((bs, ncls)).astype(cp.float32), self.device)
y = Variable(y_)
else:
y = np.zeros((bs, ncls)).astype(np.float32)
return F.concat((z, y), axis=1)
def img_tuple(state,action,Reward,state_dash,episode_end):
_state=""
_action=cp.zeros(1, dtype=cp.uint8)
_Reward=np.zeros((1, 1), dtype=np.float32)
_state_dash=""
_episode_end=np.zeros((1, 1), dtype=np.bool)
_state=state
_action[0]=cp.asarray(action)
_Reward[0][0]=Reward
_state_dash=state_dash
_episode_end[0][0]=episode_end
return (_state,_action,_Reward,_state_dash,_episode_end)
def ious_gpu_1(boxes, query_boxes):
"""Kernel function IOU computation."""
# TODO: Fix, does not work. Not using ElementwiseKernel correct.
n_boxes = boxes.shape[0]
n_query_boxes = query_boxes.shape[0]
print(n_boxes)
print(n_query_boxes)
print(boxes)
print(query_boxes)
ious = cp.zeros((n_query_boxes, n_boxes), dtype=cp.float32)
print(ious)
cp.ElementwiseKernel(
'''raw float32 boxes, float32 query_boxes, raw int32 num_boxes,
raw int32 num_query_boxes
''', 'raw float32 ious', '''
for (int q = 0; q < num_query_boxes; ++q) {
float box_area = (query_boxes[q, 2] - query_boxes[q, 0] + 1.0) *
(query_boxes[q, 3] - query_boxes[q, 1] + 1.0);
ious[q, 0] = q;
for (int b = 0; b < num_boxes; ++b) {
float iw = min(boxes[b, 2], query_boxes[q, 2]) -
max(boxes[b, 0], query_boxes[q, 0]) + 1.0;
if (iw > 0.0) {
float ih = min(boxes[b, 3], query_boxes[q, 3]) -
max(boxes[b, 1], query_boxes[q, 1]) + 1.0;
if (ih > 0.0) {
float ua = (boxes[b, 2] - boxes[b, 0] + 1.0) *
(boxes[b, 3] - boxes[b, 1] + 1.0) +
box_area - (iw * ih);
// ious[q, b] = q;
//ious[q, b] = (iw * ih) / ua;
}
} else {
ious[q, b] = -1.1;
}
}
}
''', 'intersecion_over_unions')(boxes,
query_boxes,
n_boxes,
n_query_boxes,
ious,
size=1)
return ious
def _change_one_hot_label(X):
T = xp.zeros((X.size, 10))
for idx, row in enumerate(T):
row[X[idx]] = 1
return T
def zeros(dim):
return Variable(xp.zeros(dim, dtype=xp.float32))
def _get_zeros(self, batchsize):
if self._zeros is None or self._zeros.shape[0] != batchsize:
self._zeros = np.zeros(batchsize, np.int32) if self._cpu else cp.zeros(batchsize, np.int32)
return self._zeros
def handle(self):
save_img=0
f=open(args.model,'rb')
model = pickle.load(f)
f.close()
cuda.get_device(args.gpu).use()
model.to_gpu()
if os.path.isfile(args.model2):
f=open(args.model2,'rb')
model2 = DQN.DQN_class()
model2.model = pickle.load(f)
model2.target_model_update()
f.close()
# cuda.get_device(args.gpu2).use()
model2.model.to_gpu()
model2.model_target.to_gpu()
else:
model2 = DQN.DQN_class()
# cuda.get_device(args.gpu2).use()
model2.model.to_gpu()
model2.model_target.to_gpu()
que_img = []
que_img_pass = []
#train = open('train.txt','w')
episodeCounter=0
print "episode "+str(episodeCounter+1)
double_error=0
linelist=["python compute_mean.py train.txt","python train_imagenet.py -g 0 -B 16 -b 1 -E 20 train.txt test.txt 2>&1 | tee log"]
eps=1
base_time=time.time()
time_bool=True
try:
while True:
self.data = self.request.recv(1024).strip()
if time_bool:
time_bool=False
base_time=base_time-(base_time-time.time())
self.request.send("receive")
buf=''
recvlen=0
while recvlen<int(self.data):
receivedstr=self.request.recv(1024*1024)
recvlen+=len(receivedstr)
buf +=receivedstr
img=np.fromstring(buf,dtype='uint8').reshape(740-290,670-284,3)
img_check=img[464-290:494-290,284-284:382-284,:].astype(np.float32)
_img_check = img_check.transpose(2,0,1) - mean_image
#rsvmsg=cv2.imdecode(rsvmsg,1)
height, width, depth = img.shape
new_height = size
new_width = size
if height > width:
new_width = size * width / height
else:
new_height = size * height / width
crop_height_start = ( size - new_height ) / 2
crop_height_end = crop_height_start + new_height
crop_width_start = ( size - new_width) / 2
crop_width_end = crop_width_start + new_width
resized_img = cv2.resize(img, (new_width, new_height))
cropped_img = np.zeros((size,size,3),np.uint8)
#cropped_img.fill(255) #white ver
cropped_img[crop_height_start:crop_height_end,crop_width_start:crop_width_end] = resized_img
_cropped_img = cropped_img.astype(np.float32).transpose(2,0,1)
_cropped_img -= mean_image2
_cropped_img /= 255
state_dash = cp.ndarray((1, 3, size, size), dtype=cp.float32)
state_check = cp.ndarray((1, 3, 30, 98), dtype=cp.float32)
state_dash[0]=cp.asarray(_cropped_img)
state_check[0]=cp.asarray(_img_check)
action_dash = model2.e_greedy(state_dash, eps)
_name=np.argmax(model.predict(state_check,train=False).data.get())
print action_dash
state_dash_path="save/img"+str(save_img).zfill(7)+".jpg"
cv2.imwrite(state_dash_path,cropped_img)
print "saved "+state_dash_path
save_img+=1
if len(que_img_pass)>0:
state,action=que_img_pass.pop(0)
Reward=(time.time()-base_time)*(1.0/10**3)
episode_end=False
if _name==-1:
Reward=-1
episode_end=True
que_img.append(img_tuple(state,action,Reward,state_dash_path,episode_end))
print Reward
if _name==1:
self.request.send(str(-2))
self.request.recv(1024)
if episodeCounter==19:
while len(que_img)>100000:
que_img.pop(0)
eps=1
DQN_batch_size=1
_state=cp.zeros((DQN_batch_size, 3, 224, 224),dtype=cp.float32)
_action=cp.zeros(DQN_batch_size, dtype=cp.uint8)
_Reward=np.zeros((DQN_batch_size, 1), dtype=np.float32)
_state_dash=cp.zeros((DQN_batch_size, 3, 224, 224), dtype=cp.float32)
_episode_end=np.zeros((DQN_batch_size, 1), dtype=np.bool)
for epoch in range(5):
print "epoch"+str(epoch+1)
counter=0
perm = np.random.permutation(len(que_img))
for idx in perm:
s_replay,a_replay,r_replay,s_dash_replay,episode_end_replay=que_img[idx]
_state[counter:counter+1]=load_img(s_replay)
_action[counter:counter+1]=a_replay
_Reward[counter:counter+1]=r_replay
_state_dash[counter:counter+1]=load_img(s_dash_replay)
_episode_end[counter:counter+1]=episode_end_replay
if counter==DQN_batch_size-1:
counter=0
model2.optimizer.zero_grads()
loss, _ = model2.forward(_state,_action,_Reward,_state_dash,_episode_end)
loss.backward()
model2.optimizer.update()
del loss
else:
counter+=1
del s_replay,a_replay,r_replay,s_dash_replay,episode_end_replay
episodeCounter=0
pickle.dump(model2.model, open(args.model2, 'wb'), -1)
model2.target_model_update()
#model2.model_target.to_gpu()
else:
episodeCounter+=1
base_time=time.time()
time_bool=True
print "episode "+str(episodeCounter+1)
self.request.send("OK")
else:
que_img_pass.append(img_pass_tuple(state_dash_path,action_dash))
self.request.send(str(action_dash))
eps -= 5.0/10**4
print eps
if eps < 0.1:
eps = 0.1
except KeyboardInterrupt:
pass
def img_pass_tuple(state,action):
_state=""
_action=cp.zeros(1, dtype=cp.uint8)
_state=state
_action[0]=cp.asarray(action)
return (_state,_action)
def _get_zeros(self, batchsize):
if self._zeros is None or self._zeros.shape[0] != batchsize:
self._zeros = np.zeros(batchsize,
np.int32) if self._cpu else cp.zeros(
batchsize, np.int32)
return self._zeros
