def nima_classifier(**kwargs):
# read parameters
population = kwargs.get('population')
generation = kwargs.get('generation')
tensors = kwargs.get('tensors')
f_path = kwargs.get('f_path')
objective = kwargs.get('objective')
_resolution = kwargs.get('resolution')
_stf = kwargs.get('stf')
images = True
fn = f_path + "gen" + str(generation).zfill(5)
fitness = []
best_ind = 0
# set objective function according to min/max
fit = 0
if objective == 'minimizing':
condition = lambda: (fit < max_fit) # minimizing
max_fit = float('inf')
else:
condition = lambda: (fit > max_fit) # maximizing
max_fit = float('-inf')
number_tensors = len(tensors)
with tf.device('/CPU:0'):
# NIMA classifier
x = np.stack(
[tensors[index].numpy() for index in range(number_tensors)],
axis=0)
x = preprocess_input_mob(x)
scores = model.predict(x, batch_size=number_tensors, verbose=0)
# scores
for index in range(number_tensors):
if generation % _stf == 0:
save_image(tensors[index], index, fn, 3) # save image
mean = mean_score(scores[index])
std = std_score(scores[index])
# fit = mean - std
fit = mean
if condition():
max_fit = fit
best_ind = index
fitness.append(fit)
population[index]['fitness'] = fit
# save best indiv
if images:
save_image(tensors[best_ind], best_ind, fn, 3, addon='_best')
return population, population[best_ind]
def nima_nasnet(_dir, progress=False):
target_size = (224, 224)
imgs = Path(_dir).files('*.png')
imgs += Path(_dir).files('*.jpg')
imgs += Path(_dir).files('*.jpeg')
with tf.device('/GPU:0'):
base_model = NASNetMobile((224, 224, 3),
include_top=False,
pooling='avg',
weights=None)
x = Dropout(0.75)(base_model.output)
x = Dense(10, activation='softmax')(x)
model = Model(base_model.input, x)
model.load_weights('weights/nasnet_weights.h5')
score_list = []
total_imgs = len(imgs)
for i, img_path in enumerate(imgs):
img = load_img(img_path, target_size=target_size)
x = img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
scores = model.predict(x, batch_size=1, verbose=0)[0]
mean = mean_score(scores)
std = std_score(scores)
file_name = Path(img_path).name.lower()
score_list.append((file_name, mean, std))
if progress and i % 100 == 0:
sys.stdout.write("\r%d/%d" % (i, total_imgs))
sys.stdout.flush()
# print("Evaluating : ", img_path)
# print("NIMA Score : %0.3f +- (%0.3f)" % (mean, std))
return sorted(score_list, key=lambda x: int(x[0].split('.')[0]))
def main():
print_debug(DEBUG)
# for dataset in [train_image_dir, test_image_dir]:
for dataset in [test_image_dir, train_image_dir]:
print(
'========================================================================'
)
print('INCEPTIONNET')
print('PROCESSING', dataset)
print(
'========================================================================'
)
df = pd.DataFrame(columns=['item_id', 'mean', 'std'])
print("Loading images from directory : ", dataset)
imgs = Path(dataset).files('*.png')
imgs += Path(dataset).files('*.jpg')
imgs += Path(dataset).files('*.jpeg')
N = len(imgs)
i = 0
# with tf.device("CPU:0"):
with tf.device("/device:GPU:0"):
print('>> init')
base_model = InceptionResNetV2(input_shape=(None, None, 3),
include_top=False,
pooling='avg',
weights=None)
x = Dropout(0.75)(base_model.output)
x = Dense(10, activation='softmax')(x)
print('>> load weights')
model = Model(base_model.input, x)
model.load_weights('weights/inception_resnet_weights.h5')
score_list = []
df_temp = pd.DataFrame()
if DEBUG: STEP = 3
else: STEP = 1000
if dataset == train_image_dir: todir = train_filename
else: todir = test_filename
for img_path in imgs:
if i % STEP == 0:
end_step = time.time()
print('----------------------------')
print('{}/{}'.format(i, N))
if i > 0:
print('time elapse:', end_step - start_step)
df = pd.concat([df, df_temp], axis=0)
save_pickle(df, todir)
df_temp = pd.DataFrame()
start_step = time.time()
if DEBUG: print("\n>> Evaluating : ", img_path)
img = load_img(img_path, target_size=target_size)
x = img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
scores = model.predict(x, batch_size=1, verbose=0)[0]
mean = mean_score(scores)
std = std_score(scores)
file_name = Path(img_path).name.lower()
score_list.append((file_name, mean))
if DEBUG: print("NIMA Score : %0.3f +- (%0.3f)" % (mean, std))
filename_w_ext = os.path.basename(img_path)
filename, file_extension = os.path.splitext(filename_w_ext)
temp = pd.DataFrame({
'item_id': [filename],
'mean': [mean],
'std': [std]
})
if DEBUG: print(temp)
df = pd.concat([df, temp], axis=0)
i = i + 1
df = pd.concat([df, df_temp], axis=0)
df = df.reset_index(drop=True)
print(df)
save_pickle(df, todir)
model.load_weights('weights/mobilenet_weights.h5')
score_list = []
total_score_mean = []
total_score_std = []
for img_path in imgs:
img = load_img(img_path, target_size=target_size)
x = img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
scores = model.predict(x, batch_size=1, verbose=0)[0]
mean = mean_score(scores)
std = std_score(scores)
if mean < 1000:
score_mean = mean
score_std = std
file_name = Path(img_path).name.lower()
score_list.append((file_name, mean))
print("Evaluating : ", img_path)
print("NIMA Score : %0.3f +- (%0.3f)" % (mean, std))
print()
total_score_mean.append(score_mean)
total_score_std.append(score_std)
if rank_images:
print("Reading new file: " + csv_file_path)
csv_file = pd.read_csv(csv_file_path,
sep=';',
header=None,
names=['id', 'url', 'score'])
csv_file = csv_file.fillna(0.) # set nan values in score col to 0
rows_in_file = csv_file.shape[0]
# find first row with score 0
index_list = csv_file.index[csv_file['score'] == 0.]
if len(index_list) == 0:
print("everything already predicted")
total_predicted += rows_in_file
continue
chunk_size = CHUNK_SIZE
offset = index_list[0]
total_predicted += offset
urls_list = csv_file['url'].tolist()[offset:]
total_urls = len(urls_list)
print("Found {} urls with score 0. Predicting ...".format(total_urls))
for chunk in gen_batches(urls_list, chunk_size):
scores = inference_from_urls(model, chunk, batch_size=BATCH_SIZE)
mean_scores = mean_score(scores)
csv_file.loc[offset:offset + len(chunk) - 1, 'score'] = mean_scores
offset += len(chunk)
total_predicted += len(chunk)
print("\n{}/{} | Total: {} Saving to {}".format(
offset, rows_in_file, total_predicted, csv_file_path))
csv_file.to_csv(csv_file_path, sep=';', header=False)
def generate_scores(parser):
# get the model name
model_name = parser.net
# check folder
if parser.file is None and parser.folder is None:
raise Exception('Indicate a file or a folder path')
# list the files to evaluate
if parser.folder is not None and isdir(parser.folder):
files = [join(parser.folder, file) for file in listdir(parser.folder)]
else:
files = []
# check if the file exists
if parser.file is not None and len(files) == 0 and isfile(parser.file):
files = [parser.file]
# if there is not folder or file raise exception
if len(files) == 0:
raise Exception('File or folder doesn\'t exists')
# print the files to evaluate
if parser.vb == 1:
print('---------- Files to evaluate ----------')
for i in range(len(files)):
print('{}: {}'.format(i, files[i]))
print('---------------------------------------')
# create vgg, mobilenet or inception
if model_name == 'vgg_16':
model = create_VGG()
elif model_name == 'mobilenet':
model = create_MobileNet()
elif model_name == 'inception':
model = create_Inception()
# load the weights of the network
model.load_weights('./weights/{}.h5'.format(model_name))
images = []
# load the images into memmory
for file in files:
image = cv2.resize(cv2.cvtColor(cv2.imread(file, 1), cv2.COLOR_BGR2RGB), (224, 224))/255
images.append(image)
# convert list into numpy array
images = np.array(images)
y_pred = model.predict(images)
mean_scores = [mean_score(pred) for pred in y_pred]
std_scores = [std_score(pred) for pred in y_pred]
print('-------------- Evaluation --------------')
for i in range(len(files)):
score = '{} ({}{})'.format(round(mean_scores[i], 3), chr(177), round(std_scores[i], 3))
print('{}: {} \n\t{}'.format(i, files[i], score))
print('----------------------------------------')
# save the predictions
if parser.save:
data = np.stack([files, mean_scores, std_scores], axis = 1)
df = pd.DataFrame(data = data, columns = ['file', 'mean', 'std'])
df.to_csv('evaluations.csv', index = False)
