def forward(self, images):
# TODO h_t, l_t should be random?
# TODO rename log_pi / log_probas to make more sense
log_pis = None
baselines = None
h_t = torch.zeros(images.shape[0], self.num_hidden_core, device=device)
l_t = torch.Tensor(images.shape[0], 2, device=device).uniform_(-1, 1)
for _ in range(self.num_glimpse):
g_t = self.glimseNetwork(images=images, location_prev=l_t)
h_t = self.coreNetwork(g_t=g_t, h_prev=h_t)
mu, l_t = self.locationNetwork(h_t)
b_t = self.baselineNetwork(h_t)
baselines = append(baselines, b_t, dim=1)
# we assume both dimensions are independent
# 1. pdf of the joint is the product of the pdfs
# 2. log of the product is the sum of the logs
log_pi = torch.distributions.Normal(mu, self.std).log_prob(l_t)
# This is log_prob in in Guassian Policy
log_pi = torch.sum(log_pi, dim=1)
log_pis = append(log_pis, log_pi)
log_probas = self.actionNetwork(h_t)
return log_probas, log_pis.transpose(1, 0), baselines.squeeze()
def preprocess(requests):
#Splitting the requests into [METHOD, URL, PROTOCOL]
#also dropping PROTOCOL
requests = mapt(lambda r: r.split(" ")[0:-1], requests)
print(requests[0])
#Splitting URL into path and query string
requests = mapt(lambda r: append([r[0]], r[1].split("?")), requests)
print(requests[0])
#Transform GET into 0 and POST into 1
requests = mapt(lambda r: append([0] if r[0] == "GET" else [1], r[1:3]),
requests)
print(requests[0])
return requests
def _glimp_patch(self, img, location, image_size):
# TODO it is an inaccurate if image size is odd number.
glimpse_images = None
for i in range(self.num_zoom_image):
current_img = img
glimpse_half_size = int(self.retina_size * .5 * self.scale**i)
top = int(location[0] - glimpse_half_size)
bottom = int(location[0] + glimpse_half_size)
left = int(location[1] - glimpse_half_size)
right = int(location[1] + glimpse_half_size)
if top < 0 or left < 0 or bottom > image_size or right > image_size:
pad_dims = (
glimpse_half_size,
glimpse_half_size,
glimpse_half_size,
glimpse_half_size,
)
current_img = F.pad(current_img, pad_dims, "constant", 0)
top += glimpse_half_size
bottom += glimpse_half_size
left += glimpse_half_size
right += glimpse_half_size
glimpse_images = append(
glimpse_images,
resize(current_img[:, top:bottom, left:right],
self.retina_size))
return glimpse_images
def foveate(self, imgs, locations):
"""
Args
----
imgs - (B, C, H, W)
location - (B, H, W) [-1, 1]
"""
glimpse_imgs = None
image_size = imgs[0].shape[-1]
denomalized_locations = (locations + 1) * .5 * image_size
for i, img in enumerate(imgs):
img = self._glimp_patch(img, denomalized_locations[i], image_size)
glimpse_imgs = append(glimpse_imgs, img)
return glimpse_imgs.view(glimpse_imgs.shape[0], -1) # flatten
def encode_date(date):
date_tuple = split_date(date)
date_tuple = append(date_tuple, encode_month(date_tuple[1]))
date_tuple = append(date_tuple, encode_weekday(weekday(date)))
return date_tuple
def append3(a, b, c):
return append(a, append(b, c))