def get_valid_generator(valid_df, train_df, image_dir, x_col, y_cols,
sample_size=100, batch_size=8, seed=1,
target_w=320, target_h=320):
print("getting train and valid generators...")
raw_train_generator = ImageDataGenerator().flow_from_dataframe(
dataframe=train_df,
directory=IMAGE_DIR,
x_col="Image",
y_col=labels,
class_mode="raw",
batch_size=sample_size,
shuffle=True,
target_size=(target_w,target_h))
batch = raw_train_generator.next()
data_sample = batch[0]
image_generator = ImageDataGenerator(
featurewise_center=True,
featurewise_std_normalization=True)
image_generator.fit(data_sample)
valid_generator = image_generator.flow_from_dataframe(
dataframe=valid_df,
directory=image_dir,
x_col=x_col,
y_col=y_cols,
class_mode="raw",
batch_size=batch_size,
shuffle=False,
seed=seed,
target_size=(target_w,target_h))
return valid_generator
def create_knn_model():
model = get_features_model()
index_generator = ImageDataGenerator().flow_from_directory(index_data_dir,
target_size=image_size,
batch_size=1,
class_mode='categorical',
shuffle=False)
images_path = index_generator.filenames
process_images = []
labels = []
print("Loading index images...")
for i in range(index_generator.n):
(img, lbl) = index_generator.next()
process_images.append(np.reshape(model.predict_on_batch(img), -1))
labels.append(np.argmax(lbl))
print("Loading index images to KNN model...")
knn_model = KNeighborsClassifier(n_neighbors=number_of_same_landmark)
knn_model.fit(process_images, labels)
save_knn_model(knn_model, images_path)
print("Done!")
def evaluate(model: Tuple[Model, OneHotEncoder], input_: np.ndarray):
ohe = model[1]
model = model[0]
input_shape = model.input_shape[1:4]
if input_.shape[0:2] != input_shape:
input_ = cv2.resize(input_, (input_shape[1], input_shape[0]))
if input_shape != input_.shape:
print(
f"Received shape of an input is {input_.shape} and expected shape is {input_shape}. \
Two first parameters {input_.shape[0:2]} where resized to fit a model \
so the problem is with the others{' ' + input_.shape[2:] if len(input_.shape[2:]) != 0 else ''}.",
file=sys.stderr)
exit(-1)
input_ = input_.reshape((-1, *model.input_shape[1:]))
keras_image_generator = ImageDataGenerator(
rescale=1. / 255,
samplewise_std_normalization=True,
samplewise_center=True).flow(input_,
batch_size=len(input_),
shuffle=False)
input_ = keras_image_generator.next()
prediction = model.predict(input_)
prediction = ohe.inverse_transform(prediction)
return prediction[0][0]
def extract_neural_network_features(n_iter=2):
print('Building model.')
# Extract features using Mobilenet
module_url = 'https://tfhub.dev/google/imagenet/mobilenet_v2_100_224/feature_vector/4'
# Load module
m = tf.keras.Sequential([hub.KerasLayer(module_url, trainable=False)])
# Build module
m.build([None, 224, 224, 3])
# Create generator object to collect images
transform_args = {
'rescale': 1 / 255,
'horizontal_flip': True,
'rotation_range': 22.5,
'width_shift_range': 0.05,
'height_shift_range': 0.05,
'brightness_range': (0.9, 1.1),
'zoom_range': (0.95, 1.05),
'fill_mode': 'reflect',
}
# Create generator object to collect images
generator = ImageDataGenerator(**transform_args).flow_from_directory(
'data', target_size=(224, 224), batch_size=32, shuffle=True, seed=0)
# Extract features in batches
print('Extracting features.')
# Collect data from folders
X_temp, y_temp, indeces_temp = [], [], []
n_elements = len(generator)
for batch_i in tqdm(range(len(generator) * n_iter)):
imgs, labels = generator.next()
X_temp.extend(m.predict(imgs))
y_temp.extend(labels.argmax(axis=1))
if batch_i % n_elements == 0:
indeces_temp.extend(generator.index_array)
if n_iter > 1:
print(
'Dataset was augmented to a total of N=%d images through means of:'
% len(y_temp))
print(
'Image rotation, flipping, shifting, zooming and brightness variation.\n'
)
# Extract features
X_nn = np.array(X_temp)
y_nn = np.array(y_temp)
indeces_nn = np.array(indeces_temp)
filenames = np.array(generator.filepaths)[indeces_nn]
return X_nn, y_nn
def __get_from_generator(self, generator:ImageDataGenerator):
x = []
y = []
generator.reset()
for _ in range(len(generator)):
ix, iy = generator.next()
x.append(self.__extra_txs(ix))
y.append(iy)
return (np.concatenate(x), np.concatenate(y))
def my_verifyFace(img1, img2):
aux_df = pd.DataFrame([(str(img1), "0"), (str(img2), "1")],
columns=["filename", "class"])
datagen = ImageDataGenerator(**gen_args).flow_from_dataframe(
aux_df, **flow_args)
v1, v2 = my_extractor.predict(datagen.next())[-1]
v1, v2 = np.expand_dims(v1, axis=0), np.expand_dims(v2, axis=0)
return np.stack(
[my_cos_dis.predict([v1, v2])[0],
my_base_model.predict([v1, v2])[0]],
axis=0)
def main():
image_generator = ImageDataGenerator().flow_from_directory(
f'{dataset}/test',
target_size=(image_size, image_size),
class_mode='categorical',
batch_size=batch_size,
shuffle=False)
ensemble = EnsembleModel('voting')
pred = []
gt = image_generator.labels
print('performing inference...')
for x in range(len(image_generator)):
sample = image_generator.next() # retrieves the next image
pred = np.concatenate((pred, ensemble.predict(sample[0])))
# accuracy
acc = 1 - (len(np.nonzero(pred - gt)) / len(image_generator))
print(acc)
def load_dataset(target_size=(64, 64), n_iter=2):
transform_args = {
'rescale': 1 / 255,
'horizontal_flip': True,
'rotation_range': 22.5,
'width_shift_range': 0.05,
'height_shift_range': 0.05,
'brightness_range': (0.9, 1.1),
'zoom_range': (0.95, 1.05),
'fill_mode': 'reflect',
}
# Create generator object to collect images
generator = ImageDataGenerator(**transform_args).flow_from_directory(
'data', target_size=target_size, batch_size=32, shuffle=True, seed=0)
# Collect data from folders
X, y, indeces = [], [], []
n_elements = len(generator)
for batch_i in tqdm(range(len(generator) * n_iter)):
imgs, labels = generator.next()
X.extend(imgs)
y.extend(labels.argmax(axis=1))
if batch_i % n_elements == 0:
indeces.extend(generator.index_array)
if n_iter > 1:
print(
'\nDataset was augmented to a total of N=%d images through means of:'
% len(y))
print(
'Image rotation, flipping, shifting, zooming and brightness variation.\n'
)
# Shuffle images
X = np.array(X)
y = np.array(y)
indeces = np.array(indeces)
generator.indeces = indeces
filenames = np.array(generator.filepaths)[indeces]
generator.file_paths = filenames
return X, y, generator
cae.load_weights('weights/autoencoder_fruits_weights_v1.h5')
encoder = cae.layers[0]
testing_data = ImageDataGenerator(rescale=1. / 255).flow_from_directory(
'data/fruit_samples',
target_size=(32, 32),
class_mode='categorical',
)
N = testing_data.n
iterations = N // 32
X = []
y = []
for _ in range(iterations):
batch = testing_data.next()
images = batch[0]
labels = batch[1]
latent_vectors = encoder(images).numpy()
X.append(latent_vectors)
y.append(labels)
with open('weights/dcgan_generator_fruits_architecture_v2.json', 'r') as f:
generator = tf.keras.models.model_from_json(f.read())
generator.load_weights('weights/dcgan_generator_fruits_weights_v2.h5')
X = np.concatenate(X)
y = np.concatenate(y)
def eval_folder(model_file,
data_path,
batch_size=128,
save_embeddings=None,
debug=True):
if save_embeddings and os.path.exists(save_embeddings):
print(">>>> Reloading from backup:", save_embeddings)
aa = np.load(save_embeddings)
embs, imm_classes, filenames = aa["embs"], aa["imm_classes"], aa[
"filenames"]
embs, imm_classes = embs.astype("float32"), imm_classes.astype("int")
else:
img_shape = (112, 112)
mm = tf.keras.models.load_model(model_file)
img_gen = ImageDataGenerator().flow_from_directory(
data_path,
class_mode="binary",
target_size=img_shape,
batch_size=batch_size,
shuffle=False)
steps = int(np.ceil(img_gen.classes.shape[0] / img_gen.batch_size))
filenames = np.array(img_gen.filenames)
embs, imm_classes = [], []
for _ in tqdm(range(steps), "Embedding"):
imm, imm_class = img_gen.next()
emb = mm((imm - 127.5) * 0.0078125)
embs.extend(emb)
imm_classes.extend(imm_class)
embs, imm_classes = normalize(np.array(embs).astype(
"float32")), np.array(imm_classes).astype("int")
if save_embeddings:
print(">>>> Saving embeddings to:", save_embeddings)
np.savez(save_embeddings,
embs=embs,
imm_classes=imm_classes,
filenames=filenames)
if save_embeddings:
result_name = os.path.splitext(os.path.basename(save_embeddings))[0]
else:
result_name = os.path.splitext(os.path.basename(model_file))[0]
register_ids = np.unique(imm_classes)
if debug:
print(">>>> [base info] embs:", embs.shape, "imm_classes:",
imm_classes.shape, "register_ids:", register_ids.shape)
try:
import cupy as cp
embs = cp.array(embs)
dist_func = lambda aa, bb: cp.dot(aa, bb).get()
if debug:
print(">>>> Using cupy.")
except:
dist_func = lambda aa, bb: np.dot(aa, bb)
pos_dists, neg_dists, register_base_dists = [], [], []
for register_id in tqdm(register_ids, "Evaluating"):
pick_cond = imm_classes == register_id
pos_embs = embs[pick_cond]
dists = dist_func(pos_embs, pos_embs.T)
register_base = dists.sum(0).argmax()
register_base_dist = dists[register_base]
register_base_emb = embs[pick_cond][register_base]
pos_dist = register_base_dist[
np.arange(dists.shape[0]) != register_base]
register_base_dist = dist_func(embs, register_base_emb)
neg_dist = register_base_dist[imm_classes != register_id]
pos_dists.extend(pos_dist)
neg_dists.extend(neg_dist)
register_base_dists.append(register_base_dist)
# print(">>> [register info] register_id:", register_id, "register_base_img:", filenames[pick_cond][register_base])
pos_dists = np.array(pos_dists).astype("float")
neg_dists = np.array(neg_dists).astype("float")
register_base_dists = np.array(register_base_dists).T
if debug:
print(">>>> pos_dists:", pos_dists.shape, "neg_dists:",
neg_dists.shape, "register_base_dists:",
register_base_dists.shape)
accuracy = (register_base_dists.argmax(1)
== imm_classes).sum() / register_base_dists.shape[0]
label = np.concatenate([np.ones_like(pos_dists), np.zeros_like(neg_dists)])
score = np.concatenate([pos_dists, neg_dists])
return accuracy, score, label
X_train = df.drop('y', axis=1).values.reshape(100, 28, 28, 1)
X_train = (X_train - 127.5) / 127.5
real_images = ImageDataGenerator().flow(X_train,
y=None,
batch_size=args.batch_size)
num_of_batches = real_images.n // args.batch_size
for i in range(args.epochs):
print(f'epoch {i+1}')
for j in range(num_of_batches):
print(f'batch {j+1}')
# Generate noise
noise = np.random.rand(args.batch_size, 100)
# Get real examples
real_image_batch = real_images.next()
# Generate synthetic examples
generated_images = generator.predict(noise)
# Train discriminator
discriminator.trainable = True
X = np.concatenate([real_image_batch, generated_images])
y = [1] * real_image_batch.shape[0] + [0] * noise.shape[0]
discriminator_loss = discriminator.train_on_batch(X, y)
print(f'discriminator loss: {discriminator_loss}')
# Train generator
noise = np.random.rand(args.batch_size, 100)
y_generator = [1] * args.batch_size
discriminator.trainable = False
dcgan_loss = dcgan.train_on_batch(noise, y_generator)
print(f'dcgan loss: {dcgan_loss}')
class KITTIDataInterface:
def __init__(self, train_location, batch_size):
self.train_location = train_location
self.batch_size = batch_size
self.read_data()
self.get_generators()
@staticmethod
def get_data(data_dir, image_shape):
image_paths = glob(os.path.join(data_dir, 'image_2', '*.png'))
label_paths = {
re.sub(r'_(lane|road)_', '_', os.path.basename(path)): path
for path in glob(
os.path.join(data_dir, 'gt_image_2', '*_road_*.png'))
}
images = []
gt_images = []
for image_file in tqdm(image_paths):
gt_image_file = label_paths[os.path.basename(image_file)]
image = resize(
cv2.cvtColor(cv2.imread(image_file), cv2.COLOR_BGR2RGB),
image_shape)
gt_image = resize(cv2.imread(gt_image_file), image_shape)
images.append(image)
gt_images.append(gt_image[:, :, 0])
return np.array(images), np.expand_dims(np.array(gt_images), axis=3)
def read_data(self):
x, y = KITTIDataInterface.get_data(self.train_location, (160, 576))
self.x_train, self.x_val, self.y_train, self.y_val = train_test_split(
x, y, test_size=0.1)
def get_generators(self):
SEED = 42
self.image_data_generator = ImageDataGenerator(
featurewise_center=True,
featurewise_std_normalization=True,
zoom_range=0.1).flow(self.x_train,
self.x_train,
self.batch_size,
seed=SEED)
self.mask_data_generator = ImageDataGenerator(
featurewise_center=True,
featurewise_std_normalization=True,
zoom_range=0.1).flow(self.y_train,
self.y_train,
self.batch_size,
seed=SEED)
def visualize(self, figsize=(16, 16)):
fig, axes = plt.subplots(nrows=4, ncols=2, figsize=figsize)
plt.setp(axes.flat, xticks=[], yticks=[])
x_batch, _ = self.image_data_generator.next()
y_batch, _ = self.mask_data_generator.next()
c = 1
for i, ax in enumerate(axes.flat):
if i % 2 == 0:
ax.imshow(x_batch[c])
ax.set_xlabel('Image_' + str(c))
else:
ax.imshow(y_batch[c].reshape(160, 576), cmap='gray')
ax.set_xlabel('Mask_' + str(c))
c += 1
plt.show()
@staticmethod
def data_generator(image_generator, mask_generator):
while True:
x_batch, _ = image_generator.next()
y_batch, _ = mask_generator.next()
yield x_batch, y_batch
with open('weights/autoencoder_mnist_architecture_v1.json', 'r') as f:
cae = tf.keras.models.model_from_json(f.read())
cae.load_weights('weights/autoencoder_mnist_weights_v1.h5')
encoder = cae.layers[0]
df = pd.read_pickle('data/mnist_set.pkl')
X_train = df.drop('y', axis=1).values.reshape(9100, 28, 28, 1)
X_train = ImageDataGenerator(rescale=1. / 255,
rotation_range=0.2,
width_shift_range=0.2,
height_shift_range=0.2).flow(X_train)
y = df['y'].values[:9088]
X = []
iterations = X_train.n // 32
for _ in range(iterations):
batch = X_train.next()
latent = encoder(batch).numpy()
X.append(latent)
X = np.concatenate(X)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1)
knn = KNeighborsClassifier()
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
metrics_report = classification_report(y_test, y_pred)
print(metrics_report)
cae.load_weights('weights/autoencoder_fruits_weights_v1.h5')
encoder = cae.layers[0]
testing_data = ImageDataGenerator(rescale=1. / 255).flow_from_directory(
'data/fruit_samples',
target_size=(32, 32),
class_mode='categorical',
)
N = testing_data.n
iterations = N // 32
X = []
y = []
for _ in range(iterations):
batch = testing_data.next()
images = batch[0]
labels = batch[1]
latent_vectors = encoder(images).numpy()
X.append(latent_vectors)
y.append(labels)
X = np.concatenate(X)
y = np.concatenate(y)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1)
knn = KNeighborsClassifier()
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)
import numpy as np
import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import matplotlib as mpl
mpl.use('TkAgg')
from matplotlib import pyplot as plt
if __name__ == '__main__':
imgs = ImageDataGenerator(1. / 255).flow_from_directory(
'data/fruit_small_class',
target_size=(32, 32),
class_mode='input',
batch_size=100)
imgs = imgs.next()
with open('weights/vae_fruits_architecture.json', 'r') as f:
generator = tf.keras.models.model_from_json(f.read())
generator.load_weights('weights/vae_fruits_weights.h5')
generated_images = generator.predict(imgs)
plt.figure(figsize=(10, 10))
for i in range(generated_images.shape[0]):
plt.subplot(10, 10, i + 1)
plt.imshow(generated_images[i, :, :, :])
plt.axis('off')
plt.savefig('vae_fruits_output.png')
