def plot_action_histogram(actions, title):
""" Plot the histogram of actions from the expert dataset """
acts_id = utils.unhot(actions)
fig, ax = plt.subplots()
bins = np.arange(-.5, utils.n_actions + .5)
ax.hist(acts_id, range=(0, 6), bins=bins, rwidth=.9)
ax.set(title=title, xlim=(-.5, utils.n_actions - .5))
plt.show()
def predict(optimizer):
test_dataset, test_loader = make_test_loader()
# compute predictions
logits, _ = optimizer.test(test_loader)
# compute and save raw probs
logits = np.vstack(logits)
# group and average logits (geom average predictions)
"""
Example
-------
>>> P = .01 * (np.arange(24) ** 2).reshape((8, 3))
>>> P = softmax(P)
>>> P
array([[ 0.32777633, 0.33107054, 0.34115313],
[ 0.30806966, 0.33040724, 0.3615231 ],
[ 0.28885386, 0.32895498, 0.38219116],
[ 0.27019182, 0.32672935, 0.40307883],
[ 0.25213984, 0.32375397, 0.42410619],
[ 0.23474696, 0.32005991, 0.44519313],
[ 0.21805443, 0.31568495, 0.46626061],
[ 0.20209544, 0.31067273, 0.48723183]])
>>> P.reshape(len(P)/4, 4, 3).mean(axis=1)
array([[ 0.29872292, 0.32929052, 0.37198656],
[ 0.22675917, 0.31754289, 0.45569794]])
"""
tta_n = len(logits) / 2640
logits = logits.reshape(len(logits) / tta_n, tta_n, -1)
weights = [2., 1.] if args.crop_size == 512 else [2.] * 10 + [1.] * 10
logits = np.average(logits, axis=1, weights=weights)
proba = softmax(logits)
# proba = proba.reshape(len(proba)/tta_n, tta_n, -1).mean(axis=1)
fnames = [os.path.split(fname)[-1] for fname in test_dataset.X]
df = pd.DataFrame(proba)
df['fname'] = fnames
df = df[['fname'] + range(10)]
dirpath = os.path.split(args.predict_from)[0]
df.to_csv(os.path.join(dirpath, 'proba.csv'), index=False)
# compute predictions and save in submission format
index_pred = unhot(one_hot_decision_function(proba))
data = {
'fname': fnames,
'camera':
[KaggleCameraDataset.target_labels()[int(c)] for c in index_pred]
}
df2 = pd.DataFrame(data, columns=['fname', 'camera'])
df2.to_csv(os.path.join(dirpath, 'submission.csv'), index=False)
def train(self, X, Y, learning_rate=0.05, max_iter=3, batch_size=32):
"""Train network on the given data."""
print ('train network with \n \
learning_rate: %.4f, \n \
max_iter: %d, \n \
batch_size: %d \n' \
%(learning_rate, max_iter, batch_size))
num_sample = Y.shape[0]
num_batch = num_sample // batch_size
# Y_one_hot = one_hot(Y)
self._setup(X, Y)
self.display()
iter = 0
# Stochastic gradient descent with mini-batches
while iter < max_iter:
iter += 1
for b in range(num_batch):
batch_begin = b * batch_size
batch_end = batch_begin + batch_size
X_batch = X[batch_begin:batch_end]
Y_batch = Y[batch_begin:batch_end]
# Forward propagation
Y_pred = self.forward(X_batch)
# Back propagation of partial derivatives
self.backward(Y_batch, Y_pred, learning_rate)
# Output training status
loss = self._loss(X, Y)
# loss = self.layers[-1].loss(Y_batch, Y_pred)
error = self.error(X, unhot(Y))
# error = unhot(Y_pred) != Y
# error = np.mean(error)
print("iter %i, loss %.4f, train error %.4f' " %
(iter, loss, error))
def train(self, X, Y, learning_rate=0.05, max_iter=3, batch_size=32):
"""Train network on the given data."""
print ('train network with \n \
learning_rate: %.4f, \n \
max_iter: %d, \n \
batch_size: %d \n' \
%(learning_rate, max_iter, batch_size))
num_sample = Y.shape[0]
num_batch = num_sample//batch_size
# Y_one_hot = one_hot(Y)
self._setup(X, Y)
self.display()
iter = 0
# Stochastic gradient descent with mini-batches
while iter < max_iter:
iter += 1
for b in range(num_batch):
batch_begin = b*batch_size
batch_end = batch_begin + batch_size
X_batch = X[batch_begin:batch_end]
Y_batch = Y[batch_begin:batch_end]
# Forward propagation
Y_pred = self.forward(X_batch)
# Back propagation of partial derivatives
self.backward(Y_batch, Y_pred, learning_rate)
# Output training status
loss = self._loss(X, Y)
# loss = self.layers[-1].loss(Y_batch, Y_pred)
error = self.error(X, unhot(Y))
# error = unhot(Y_pred) != Y
# error = np.mean(error)
print("iter %i, loss %.4f, train error %.4f' " % (iter, loss, error))
def predict(optimizer, **kwargs):
# load data
X_test = np.load(os.path.join(kwargs['data_path'], 'X_test.npy'))
y_test = np.zeros((len(X_test), ), dtype=np.int64)
test_transform = transforms.Compose([
transforms.Lambda(lambda x: Image.fromarray(x)),
transforms.ToTensor(),
transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
# TTA
rng = RNG(seed=1337)
base_transform = transforms.Compose([
transforms.Lambda(lambda x: Image.fromarray(x)),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
transforms.Lambda(
lambda img: [img, img.transpose(Image.ROTATE_90)][int(rng.rand() <
0.5)]),
transforms.Lambda(
lambda img: adjust_gamma(img, gamma=rng.uniform(0.8, 1.25))),
transforms.Lambda(
lambda img: jpg_compress(img, quality=rng.randint(70, 100 + 1))),
transforms.ToTensor(),
transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
tta_n = 10
def tta_f(img, n=tta_n - 1):
out = [test_transform(img)]
for _ in xrange(n):
out.append(base_transform(img))
return torch.stack(out, 0)
tta_transform = transforms.Compose([
transforms.Lambda(lambda img: tta_f(img)),
])
test_loader = DataLoader(dataset=make_numpy_dataset(
X_test, y_test, tta_transform),
batch_size=kwargs['batch_size'],
shuffle=False,
num_workers=4)
test_dataset = KaggleCameraDataset(kwargs['data_path'],
train=False,
lazy=not kwargs['not_lazy'])
# compute predictions
logits, _ = optimizer.test(test_loader)
# compute and save raw probs
logits = np.vstack(logits)
proba = softmax(logits)
# group and average predictions
K = 16 * tta_n
proba = proba.reshape(len(proba) / K, K, -1).mean(axis=1)
fnames = [os.path.split(fname)[-1] for fname in test_dataset.X]
df = pd.DataFrame(proba)
df['fname'] = fnames
df = df[['fname'] + range(10)]
dirpath = os.path.split(kwargs['predict_from'])[0]
df.to_csv(os.path.join(dirpath, 'proba.csv'), index=False)
# compute predictions and save in submission format
index_pred = unhot(one_hot_decision_function(proba))
data = {
'fname': fnames,
'camera':
[KaggleCameraDataset.target_labels()[int(c)] for c in index_pred]
}
df2 = pd.DataFrame(data, columns=['fname', 'camera'])
df2.to_csv(os.path.join(dirpath, 'submission.csv'), index=False)
def predict(self, X):
""" Calculate an output Y for the given input X. """
Y_pred = self.forward(X)
Y_pred = unhot(Y_pred)
return Y_pred
def predict(self, X):
""" Calculate an output Y for the given input X. """
Y_pred = self.forward(X)
Y_pred = unhot(Y_pred)
return Y_pred