def getTokenizedStream(X, Y, sources,
batch_size=128, embedding_dim=300):
"""getTokenizedStream returns data with images as cnn features
and captions as tokenized words. NOT glove vectors.
This is being used for the end2end implementation. See google's paper
"Show and Tell: Generating Image Captions". Thus we are not using
contrastive examples either.
"""
trX, trY = (X, Y)
# Transforms
trXt=lambda x: floatX(x)
Yt=lambda y: intX(SeqPadded(vect.transform(sampleCaptions(y)), 'back'))
# Foxhound Iterators
# RCL: Write own iterator to sample positive examples/captions, since there are 5 for each image.
train_iterator = iterators.Linear(
trXt=trXt, trYt=Yt, size=batch_size, shuffle=False
)
# FoxyDataStreams
train_stream = FoxyDataStream(
(trX, trY)
, sources
, train_iterator
, FoxyIterationScheme(len(trX), batch_size)
)
train_stream.iteration_scheme = FoxyIterationScheme(len(trX), batch_size)
return train_stream
def getMLBStream(X, Y, sources, batch_size=128, embedding_dim=300,
shuffle=False):
"""Returns sources in the format
(sources[0], sources[1]--MultiLabelBinarized)
"""
trX, trY = (X, Y)
# Transforms
trXt=lambda x: floatX(x)
Yt=lambda y: intX(mlb.transform(vect.transform(concatCaptions(y))))
# Foxhound Iterators
train_iterator = iterators.Linear(
trXt=trXt, trYt=Yt, size=batch_size, shuffle=shuffle
)
# FoxyDataStreams
train_stream = FoxyDataStream(
(trX, trY)
, sources
, train_iterator
, FoxyIterationScheme(len(trX), batch_size)
)
train_stream.iteration_scheme = FoxyIterationScheme(len(trX), batch_size)
return train_stream
def __call__(self, params, cost, consider_constant=None):
updates = []
# if self.clipnorm > 0:
# print('clipping grads', self.clipnorm)
# grads = T.grad(theano.gradient.grad_clip(cost, 0, self.clipnorm), params)
grads = T.grad(cost, params, consider_constant=consider_constant)
grads = clip_norms(grads, self.clipnorm)
t = theano.shared(floatX(1.))
b1_t = self.b1*self.l**(t-1)
for p, g in zip(params, grads):
g = self.regularizer.gradient_regularize(p, g)
m = theano.shared(p.get_value() * 0.)
v = theano.shared(p.get_value() * 0.)
m_t = b1_t*m + (1 - b1_t)*g
v_t = self.b2*v + (1 - self.b2)*g**2
m_c = m_t / (1-self.b1**t)
v_c = v_t / (1-self.b2**t)
p_t = p - (self.lr * m_c) / (T.sqrt(v_c) + self.e)
p_t = self.regularizer.weight_regularize(p_t)
updates.append((m, m_t))
updates.append((v, v_t))
updates.append((p, p_t) )
updates.append((t, t + 1.))
return updates
def getFinalStream(X, Y, sources, sources_k, batch_size=128, embedding_dim=300,
shuffle=False):
"""Despite horrible variable names, this method
gives back the final stream for both train or test data
batch_size:
embedding_dim: for glove vects
min_df and max_features: for Tokenizer
Returns
-------
merged stream with sources = sources + sources_k
"""
trX, trY = (X, Y)
trX_k, trY_k = (X, Y)
# Transforms
trXt=lambda x: floatX(x)
Yt=lambda y: intX(SeqPadded(vect.transform(sampleCaptions(y)), 'back'))
# Foxhound Iterators
# RCL: Write own iterator to sample positive examples/captions, since there are 5 for each image.
train_iterator = iterators.Linear(
trXt=trXt, trYt=Yt, size=batch_size, shuffle=shuffle
)
train_iterator_k = iterators.Linear(
trXt=trXt, trYt=Yt, size=batch_size, shuffle=shuffle
)
# FoxyDataStreams
train_stream = FoxyDataStream(
(trX, trY)
, sources
, train_iterator
, FoxyIterationScheme(len(trX), batch_size)
)
train_stream_k = FoxyDataStream(
(trX_k, trY_k)
, sources_k
, train_iterator_k
, FoxyIterationScheme(len(trX), batch_size)
)
glove_version = "glove.6B.%sd.txt.gz" % embedding_dim
train_transformer = GloveTransformer(
glove_version, data_stream=train_stream, vectorizer=vect
)
train_transformer_k = GloveTransformer(
glove_version, data_stream=train_stream_k, vectorizer=vect
)
# Final Data Streams w/ contrastive examples
final_train_stream = Merge(
(train_transformer, ShuffleBatch(train_transformer_k))
, sources + sources_k
)
final_train_stream.iteration_scheme = FoxyIterationScheme(len(trX), batch_size)
return final_train_stream
def getFinalStream(X,
Y,
sources,
sources_k,
batch_size=128,
embedding_dim=300,
shuffle=False):
"""
Returns
-------
merged stream with sources = sources + sources_k
"""
trX, trY = (X, Y)
trX_k, trY_k = (X, Y)
# Transforms
trXt = lambda x: floatX(x)
Yt = lambda y: intX(
SeqPadded(vect.transform(sampleCaptions(y)), 'back'))
# Foxhound Iterators
# RCL: Write own iterator to sample positive examples/captions, since there are 5 for each image.
train_iterator = iterators.Linear(trXt=trXt,
trYt=Yt,
size=batch_size,
shuffle=shuffle)
train_iterator_k = iterators.Linear(trXt=trXt,
trYt=Yt,
size=batch_size,
shuffle=True)
# FoxyDataStreams
train_stream = FoxyDataStream(
(trX, trY), sources, train_iterator,
FoxyIterationScheme(len(trX), batch_size))
train_stream_k = FoxyDataStream(
(trX_k, trY_k), sources_k, train_iterator_k,
FoxyIterationScheme(len(trX), batch_size))
glove_version = "glove.6B.%sd.txt.gz" % embedding_dim
train_transformer = GloveTransformer(glove_version,
data_stream=train_stream,
vectorizer=vect)
train_transformer_k = GloveTransformer(glove_version,
data_stream=train_stream_k,
vectorizer=vect)
# Final Data Streams w/ contrastive examples
final_train_stream = Merge(
(train_transformer, ShuffleBatch(train_transformer_k)),
sources + sources_k)
final_train_stream.iteration_scheme = FoxyIterationScheme(
len(trX), batch_size)
return final_train_stream
def iterXY(self, X, Y):
if self.shuffle:
X, Y = shuffle(X, Y)
self.loader = Loader(X, self.train_load, self.train_transform, self.size)
self.proc = Process(target=self.loader.load)
self.proc.start()
for ymb in iter_data(Y, size=self.size):
xmb = self.loader.get()
yield xmb, floatX(ymb)
def iterXY(self, X, Y):
if self.shuffle:
X, Y = shuffle(X, Y)
self.loader = Loader(X, self.train_load, self.train_transform,
self.size)
self.proc = Process(target=self.loader.load)
self.proc.start()
for ymb in iter_data(Y, size=self.size):
xmb = self.loader.get()
yield xmb, floatX(ymb)
kde = gaussian_kde(gs)
plt.clf()
plt.plot(xs, ps, '--', lw=2)
plt.plot(xs, kde(xs), lw=2)
plt.plot(xs, preal, lw=2)
plt.xlim([-5., 5.])
plt.ylim([0., 1.])
plt.ylabel('Prob')
plt.xlabel('x')
plt.legend(['P(data)', 'G(z)', 'D(x)'])
plt.title('GAN learning guassian')
fig.canvas.draw()
plt.show(block=False)
show()
#Train both networks
for i in range(100):
#get the uniform distribution of both networks
zmb = np.random.uniform(-1, 1, size=(batch_size, 1)).astype('float32')
xmb = np.random.normal(1., 1, size=(batch_size, 1)).astype('float32')
if i % 10 == 0:
_train_g(xmb, zmb)
else:
_train_d(xmb, zmb)
if i % 10 == 0:
print(i)
vis(i)
lrt.set_value(floatX(lrt.get_value() * 0.9999))
preal = _score(xs.reshape(-1, 1)).flatten()
kde = gaussian_kde(gs)
plt.clf()
plt.plot(xs, ps, '--', lw=2)
plt.plot(xs, kde(xs), lw=2)
plt.plot(xs, preal, lw=2)
plt.xlim([-5., 5.])
plt.ylim([0., 1.])
plt.ylabel('Prob')
plt.xlabel('x')
plt.legend(['P(data)', 'G(z)', 'D(x)'])
plt.title('GAN learning guassian')
fig.canvas.draw()
plt.show(block=False)
show()
#Train both networks
for i in range(100):
#get the uniform distribution of both networks
zmb = np.random.uniform(-1, 1, size=(batch_size, 1)).astype('float32')
xmb = np.random.normal(1., 1, size=(batch_size, 1)).astype('float32')
if i % 10 == 0:
_train_g(xmb, zmb)
else:
_train_d(xmb, zmb)
if i % 10 == 0:
print i
vis(i)
lrt.set_value(floatX(lrt.get_value()*0.9999))
which assumes that y_hat is shape (n_examples, n_classes).
This doesn't always work when our y is not one-hotted
# error_rate = MisclassificationRate().apply(y, y_hat)
"""
cg = ComputationGraph(cost)
# # # # # # # # # # #
# Modeling Training #
# # # # # # # # # # #
# Transforms
trXt=lambda x: intX(SeqPadded(vect.transform(LenClip(x, 1000))))
teXt=lambda x: intX(SeqPadded(vect.transform(x)))
Yt=lambda y: floatX(y).reshape(-1, 1)
# Foxhound Iterators
train_iterator = iterators.Linear(trXt=trXt, trYt=Yt)
test_iterator = iterators.Linear(trXt=teXt, trYt=Yt)
# DataStreams
train_stream = FoxyDataStream(trX, trY, train_iterator)
test_stream = FoxyDataStream(teX, teY, test_iterator)
# import ipdb
# ipdb.set_trace()
# Train
algorithm = GradientDescent(
cost=cost
, parameters=cg.parameters
ops.Project(dim=500),
ops.Activation('tanh'),
ops.Project(dim=75),
ops.Activation('tanh'),
ops.Project(dim=75),
ops.Activation('tanh'),
ops.Project(dim=75),
ops.Activation('tanh'),
ops.Project(dim=1),
ops.Activation('sigmoid')
]
return model
# Learn and Predict
trXt = lambda x: floatX((np.asarray(x)))
teXt = trXt
if binary_output:
trYt = lambda y: floatX(y)
else:
trYt = lambda y: floatX(OneHot(y, 2))
iterator = iterators.Linear(size=80, trXt=trXt, teXt=teXt, trYt=trYt)
model = model_MLP(trX.shape[1])
model = Network(model, iterator=iterator)
continue_epochs = True
min_cost_delta = .00001
min_cost = .001
cost0, cost1 = None, None
epoch_count = 0
# Figure out data source
train = CIFAR10("train")
test = CIFAR10("test")
# Load Data Using Fuel
train_stream = DataStream.default_stream(
dataset=train
, iteration_scheme=ShuffledScheme(train.num_examples, batch_size=128))
test_stream = DataStream.default_stream(
dataset=test
, iteration_scheme=ShuffledScheme(test.num_examples, batch_size=1024))
train_epoch, test_epoch = [stream.get_epoch_iterator() for stream in [train_stream, test_stream]]
trXt = lambda x: floatX(Fliplr(Patch(np.asarray(x).transpose(0, 2, 3, 1), 28, 28))).transpose(0, 3, 1, 2)
teXt = lambda x: floatX(CenterCrop(np.asarray(x).transpose(0, 2, 3, 1), 28, 28)).transpose(0, 3, 1, 2)
trYt = lambda y: floatX(OneHot(y, 10))
iterator = iterators.Linear(trXt=trXt, teXt=teXt, trYt=trYt)
def get_entire_stream(epoch_iterator):
Xs = []
Ys = []
for xmb, ymb in epoch_iterator:
Xs.append(xmb)
Ys.append(ymb)
X = np.vstack(Xs)
Y = np.hstack(Ys)
return X, Y
ops.Project(dim=500),
ops.Activation("tanh"),
ops.Project(dim=75),
ops.Activation("tanh"),
ops.Project(dim=75),
ops.Activation("tanh"),
ops.Project(dim=75),
ops.Activation("tanh"),
ops.Project(dim=1),
ops.Activation("sigmoid"),
]
return model
# Learn and Predict
trXt = lambda x: floatX((np.asarray(x)))
teXt = trXt
if binary_output:
trYt = lambda y: floatX(y)
else:
trYt = lambda y: floatX(OneHot(y, 2))
iterator = iterators.Linear(size=80, trXt=trXt, teXt=teXt, trYt=trYt)
model = model_MLP(trX.shape[1])
model = Network(model, iterator=iterator)
continue_epochs = True
min_cost_delta = 0.00001
min_cost = 0.001
cost0, cost1 = None, None
epoch_count = 0
