def __init__(self, fold=0, preprocess_input=preprocess_input):
super().__init__()
self.preprocess_input = preprocess_input
print('build clip transforms')
self.clip_transforms = {
video_id: self.transform_for_clip(video_id) for video_id in self.video_clips
}
self.data = [] # type: List[FishClassification]
# video_id->frame->species:
self.known_species = {} # type: Dict[str, Dict[int, int]]
self.data, self.known_species = self.load()
all_video_ids = set(self.video_clips.keys())
self.test_video_ids = set(dataset.fold_test_video_ids(fold))
self.train_video_ids = all_video_ids.difference(self.test_video_ids)
self.train_data = [d for d in self.data if d.video_id in self.train_video_ids]
self.test_data_full = [d for d in self.data if d.video_id in self.test_video_ids]
self.test_data = self.test_data_full[::2]
self.test_data_for_clip = {}
for d in self.test_data_full:
if not d.video_id in self.test_data_for_clip:
self.test_data_for_clip[d.video_id] = []
self.test_data_for_clip[d.video_id].append(d)
self.crops_cache = {}
print('train samples: {} test samples {}'.format(len(self.train_data), len(self.test_data)))
def __init__(self,
fold,
detection_results_dir='../output/detection_results',
classification_results_dir='../output/classification_results',
train_on_all_dataset=True,
load_only_video_ids=None,
is_test=False):
self.video_clips = dataset.video_clips(is_test=is_test)
if load_only_video_ids is not None:
all_video_ids = set(load_only_video_ids)
else:
all_video_ids = set(self.video_clips.keys())
if train_on_all_dataset:
self.test_video_ids = []
self.train_video_ids = all_video_ids
else:
self.test_video_ids = set(dataset.fold_test_video_ids(fold))
self.train_video_ids = all_video_ids.difference(
self.test_video_ids)
self.gt = pd.read_csv(
'../input/N1_fish_N2_fish_-_Training_set_annotations.csv')
self.gt.dropna(axis=0, inplace=True)
self.gt['have_frame'] = 1.0
self.video_frames_count = {}
self.video_data = {}
self.video_data_gt = {}
print('load video data...')
cache_fn = '../output/sequence_rnn_test.pkl' if is_test else '../output/sequence_rnn_train.pkl'
try:
self.video_frames_count, self.video_data, self.video_data_gt, self.columns = utils.load_data(
cache_fn)
except FileNotFoundError:
self.video_frames_count, self.video_data, self.video_data_gt, self.columns = self.load(
all_video_ids, detection_results_dir,
classification_results_dir)
utils.save_data((self.video_frames_count, self.video_data,
self.video_data_gt, self.columns), cache_fn)
print('loaded')
def generate_results_from_detection_crops_on_fold(fold,
weights,
crops_dir,
output_dir,
video_ids=None,
hflip=0,
vflip=0,
model_type=''):
preprocess_input_func = preprocess_input
if model_type in ('densenet', 'densenet2'):
model = build_model_densenet_161()
elif model_type in ('densenet121', ):
model = build_model_densenet_121()
elif model_type == 'resnet50':
model = build_model_resnet50()
elif model_type == 'resnet50_mask':
model = build_model_resnet50_with_mask()
elif model_type == 'resnet50_mask5':
model = build_model_resnet50_with_mask()
elif model_type in ('xception', 'xception5'):
model = build_model_xception()
preprocess_input_func = preprocess_input_xception
elif model_type == 'inception':
model = build_model_inception()
preprocess_input_func = preprocess_input_inception
else:
print('Invalid model_type', model_type)
return
model.load_weights(weights)
os.makedirs(output_dir, exist_ok=True)
executor = concurrent.futures.ThreadPoolExecutor(max_workers=16)
if video_ids is None:
video_ids = sorted(dataset.fold_test_video_ids(fold))
batch_size = 8
for video_id in video_ids:
src_dir = os.path.join(crops_dir, video_id)
try:
files = [
f for f in sorted(os.listdir(src_dir)) if f.endswith('.jpg')
]
except FileNotFoundError:
print('Warning: no images found in ', src_dir)
files = []
def load_data():
for batch_files in utils.chunks(files, batch_size):
res = []
for fn in batch_files:
# print('load', fn)
img = scipy.misc.imread(os.path.join(src_dir, fn))
if hflip:
img = img[:, ::-1]
if vflip:
img = img[::-1]
# utils.print_stats('img', img)
# img = np.load(os.path.join(src_dir, fn))
# plt.imshow(img)
# plt.show()
img = img.astype(np.float32) # * 255.0
res.append(img)
res = np.array(res)
yield preprocess_input_func(res)
results_species = []
results_cover = []
for batch_data in utils.parallel_generator(load_data(), executor):
# for batch_data in load_data():
res_species, res_cover = model.predict_on_batch(batch_data)
#
# for i in range(batch_data.shape[0]):
# print(SPECIES_CLASSES[np.argmax(res_species[i])],
# COVER_CLASSES[np.argmax(res_cover[i])])
# print(res_species[i])
# print(res_cover[i])
results_species.append(res_species)
results_cover.append(res_cover)
frames = [int(f[:-len('.npy')]) - 1 for f in files]
df = pd.DataFrame({'frame': frames})
df['video_id'] = video_id
if len(results_species) == 0:
results_species = np.zeros((0, len(SPECIES_CLASSES)))
results_cover = np.zeros((0, len(COVER_CLASSES)))
else:
results_species = np.row_stack(results_species)
results_cover = np.row_stack(results_cover)
for i, species_cls in enumerate(SPECIES_CLASSES):
df['species_' + species_cls] = results_species[:, i]
for i, cover_cls in enumerate(COVER_CLASSES):
df[cover_cls] = results_cover[:, i]
df.to_csv(os.path.join(output_dir, video_id + '_categories.csv'),
index=False,
float_format='%.4f')
def __init__(self,
fold,
detection_results_dir='../output/detection_results',
classification_results_dir='../output/classification_results',
load_only_video_ids=None):
self.video_clips = dataset.video_clips()
if load_only_video_ids is not None:
all_video_ids = set(load_only_video_ids)
else:
all_video_ids = set(self.video_clips.keys())
self.test_video_ids = set(dataset.fold_test_video_ids(fold))
self.train_video_ids = all_video_ids.difference(self.test_video_ids)
self.gt = pd.read_csv(
'../input/N1_fish_N2_fish_-_Training_set_annotations.csv')
self.gt.dropna(axis=0, inplace=True)
self.gt['have_frame'] = 1.0
self.video_frames_count = {}
self.video_data = {}
self.video_data_gt = {}
for video_id in sorted(all_video_ids):
try:
ds_detection = pd.read_csv(
os.path.join(detection_results_dir,
video_id + '_ssd_detection.csv'))
ds_classification = pd.read_csv(
os.path.join(classification_results_dir,
video_id + '_categories.csv'))
except FileNotFoundError:
continue
ds_combined = ds_classification.join(ds_detection,
on='frame',
how='left',
rsuffix='_det')
ds_combined.x /= IMG_WITH
ds_combined.y /= IMG_HEIGHT
ds_combined.w /= IMG_WITH
ds_combined.h /= IMG_HEIGHT
nb_frames = len(self.video_clips[video_id])
self.video_frames_count[video_id] = nb_frames
all_frames = pd.DataFrame({'frame': list(range(nb_frames))})
ds_combined = all_frames.merge(ds_combined, on='frame',
how='left').fillna(0.0)
ds_combined['species__'] = 1.0 - (
ds_combined['species_fourspot'] +
ds_combined['species_grey sole'] +
ds_combined['species_other'] + ds_combined['species_plaice'] +
ds_combined['species_summer'] +
ds_combined['species_windowpane'] +
ds_combined['species_winter'])
self.columns = [
'species__', 'species_fourspot', 'species_grey sole',
'species_other', 'species_plaice', 'species_summer',
'species_windowpane', 'species_winter', 'no fish',
'hand over fish', 'fish clear', 'x', 'y', 'w', 'h',
'detection_conf', 'detection_species'
]
self.video_data[video_id] = ds_combined.as_matrix(
columns=self.columns)
gt_combined = all_frames.merge(
self.gt.loc[self.gt.video_id == video_id],
on='frame',
how='left').fillna(0.0)
self.video_data_gt[video_id] = gt_combined.as_matrix(
columns=['have_frame'])