def get_or_train_cav(concepts,
bottleneck,
acts,
cav_dir=None,
cav_hparams=None,
overwrite=False):
"""Gets, creating and training if necessary, the specified CAV.
Assumes the activations already exists.
Args:
concepts: set of concepts used for CAV
Note: if there are two concepts, provide the positive concept
first, then negative concept (e.g., ['striped', 'random500_1']
bottleneck: the bottleneck used for CAV
acts: dictionary contains activations of concepts in each bottlenecks
e.g., acts[concept][bottleneck]
cav_dir: a directory to store the results.
cav_hparams: a parameter used to learn CAV
overwrite: if set to True overwrite any saved CAV files.
Returns:
returns a CAV instance
"""
if cav_hparams is None:
cav_hparams = CAV.default_hparams()
if cav_dir is not None:
utils.make_dir_if_not_exists(cav_dir)
cav_path = os.path.join(
cav_dir,
CAV.cav_key(concepts, bottleneck, cav_hparams.model_type,
cav_hparams.alpha).replace('/', '.') + '.pkl')
if not overwrite and os.path.exists(cav_path):
try:
tf.logging.debug('CAV already exists: {}'.format(cav_path))
cav_instance = CAV.load_cav(cav_path)
cav_instance.cavs /= np.linalg.norm(
cav_instance.cavs) # normalize
tf.logging.info('Loaded CAV accuracies: {}'.format(
cav_instance.accuracies))
return cav_instance
except:
tf.logging.info('Fail loading CAV. Now calculating...')
tf.logging.debug('Training CAV {} - {} alpha {}'.format(
concepts, bottleneck, cav_hparams.alpha))
cav_instance = CAV(concepts, bottleneck, cav_hparams, cav_path)
cav_instance.train({c: acts[c] for c in concepts})
cav_instance.cavs /= np.linalg.norm(cav_instance.cavs) # normalize
tf.logging.info('CAV accuracies: {}'.format(cav_instance.accuracies))
return cav_instance
def make_directories(self):
self.working_dir = os.path.join(self.project_dir,
"tmp/{}".format(self.model_to_run))
self.activation_dir = os.path.join(self.working_dir, 'activations/')
self.cav_dir = os.path.join(self.working_dir, 'cavs/')
self.source_dir = os.path.join(self.project_dir, "source_dir")
print(self.working_dir)
print(self.activation_dir)
print(self.cav_dir)
print(self.source_dir)
utils.make_dir_if_not_exists(self.activation_dir)
utils.make_dir_if_not_exists(self.working_dir)
utils.make_dir_if_not_exists(self.cav_dir)
# Name of parent directory that results are stored
project_name = 'tcav_class_test'
working_dir = 'D:\\tcav_working_dir'
# Where activations are stored
activation_dir = working_dir + '/activations/'
# Where CAVs are stored
cav_dir = working_dir + '/cavs/'
# Where the images live
source_dir = 'D:\\tcav_data_file'
# bottlenecks = ['layer1', 'layer2', 'layer3'] # @param # Reduced to save time
bottlenecks = ['layer2']
utils.make_dir_if_not_exists(working_dir)
utils.make_dir_if_not_exists(activation_dir)
utils.make_dir_if_not_exists(cav_dir)
LABEL_PATH = './imagenet_comp_graph_label_strings.txt'
# This is a regularizer penalty parameter for linear classifier to get CAVs
alphas = [0.1]
target = 'cat'
# concepts = ["dotted", "striped", "zigzagged"] # Reduced to save time
concepts = ['striped']
random_counterpart = 'random500_500'
my_model = model.SmallResNet50Wrapper(LABEL_PATH)
act_generator = activation_generator.ImageActivationGenerator(
my_model, source_dir, activation_dir, max_examples=40)
def run_tcav(model, dataset, previous_tcav_dict=None):
dataset_name = dataset.dataset_name
id_to_labels = dataset.id_to_label
model_to_run = 'inception_v3'
tcav_dir = "models/tensorflow_inception_v3_tcav_temps"
# where activations are stored (only if your act_gen_wrapper does so)
activation_dir = os.path.join(tcav_dir, 'activations/')
# where CAVs are stored.
# You can say None if you don't wish to store any.
cav_dir = os.path.join(tcav_dir, 'cavs/')
concept_directory = "datasets/tcav_concepts"
target_directory = "datasets/image_ILSVRC2012_validation"
bottlenecks = ['Mixed_5d', 'Mixed_7c'] # @param
utils.make_dir_if_not_exists(activation_dir)
utils.make_dir_if_not_exists(cav_dir)
# this is a regularizer penalty parameter for linear classifier to get CAVs.
alphas = [0.1]
# a folder that random images are stored
random_counterpart = 'random_images'
#targets = random.sample(id_to_labels.keys(), 50)
targets = [286, 370, 757, 595, 147, 108, 478, 517, 334, 173, 948, 727, 23]
if -1 in targets:
targets.remove(-1)
print(targets)
concepts = [
dI for dI in os.listdir(concept_directory)
if os.path.isdir(os.path.join(concept_directory, dI))
and "random" not in dI and "." not in dI
]
the_model = TCAVInceptionWrapperSlim(model.session, model, id_to_labels)
act_generator = act_gen.ImageActivationGenerator(
the_model,
concept_directory,
activation_dir,
max_examples=100,
target_dir=target_directory,
label_to_element_dict=dataset.label_to_elements)
tf.logging.set_verbosity(0)
if previous_tcav_dict == None:
tcav_dict = previous_tcav_dict
else:
tcav_dict = {}
for target in targets:
mytcav = TCAV(model.session,
target,
concepts,
bottlenecks,
act_generator,
alphas,
random_counterpart,
cav_dir=cav_dir,
num_random_exp=19,
use_numeric_class_label=True)
results = mytcav.run(run_parallel=True, num_workers=5)
tcav_dict = utils.print_results(results,
class_id=target,
result_dict=tcav_dict)
tcav_file_path = os.path.join(
"models",
dataset_name + model.model_name + '-tcavscores-2' + '.pkl')
with open(tcav_file_path, 'wb') as f:
pickle.dump(tcav_dict, f, pickle.HIGHEST_PROTOCOL)
return tcav_dict
def run_tcav():
model = get_model_list("../../models/")[0]
dataset = get_dataset_list("../../datasets")[0]
dataset_name = dataset.dataset_name
id_to_labels = dataset.id_to_label
model_to_run = 'inception_v3'
tcav_dir = "../../models/tensorflow_inception_v3"
# where activations are stored (only if your act_gen_wrapper does so)
activation_dir = os.path.join(tcav_dir, 'activations/')
# where CAVs are stored.
# You can say None if you don't wish to store any.
cav_dir = os.path.join(tcav_dir, 'cavs/')
concept_directory = "../../datasets/tcav_concepts"
target_directory = "../../datasets/targets"
bottlenecks = ['Mixed_5d'] # @param
utils.make_dir_if_not_exists(activation_dir)
utils.make_dir_if_not_exists(cav_dir)
# this is a regularizer penalty parameter for linear classifier to get CAVs.
alphas = [0.1]
# a folder that random images are stored
random_counterpart = 'random_images'
targets = ['zebra']
concepts = ["dotted", "striped", "zigzagged", "irregular pattern", "gradient", "single color"]
#crawl images for concepts and target class
for concept in concepts:
if not os.path.isdir(os.path.join(concept_directory, concept)):
image_crawler.crawl_images(concept_directory, concept, N=50)
# if not os.path.isdir(os.path.join(concept_directory, random_counterpart)):
# image_crawler.crawl_images(concept_directory, 'image', N=500)
for target in targets:
if not os.path.isdir(os.path.join(target_directory, target)):
image_crawler.crawl_images(target_directory, target, N=50)
the_model = cm.InceptionV3Wrapper_custom(model.session,
model,
id_to_labels)
act_generator = act_gen.ImageActivationGenerator(the_model, concept_directory, activation_dir, max_examples=100)
tf.logging.set_verbosity(0)
tcav_dict = {}
for target in targets:
mytcav = TCAV(model.session,
target,
concepts,
bottlenecks,
act_generator,
alphas,
random_counterpart,
cav_dir=cav_dir,
num_random_exp=5)
results = mytcav.run()
# we have to subtract 1 from the target class, as it corresponds with our ground truth labels,
# internally the network outputs are shifted by one, as 0 represents the background class instead of -1
summary = utils.print_results(results, class_id=the_model.label_to_id(target)-1, result_dict=tcav_dict)
tcav_file_path = os.path.join(model.model_path, dataset_name + model.model_name + '-tcavscores' + '.pkl')
with open(tcav_file_path, 'wb') as f:
pickle.dump(tcav_dict, f, pickle.HIGHEST_PROTOCOL)
def create_tcav_dirs(dataset=None,
model=None,
concept_dir="datasets/tcav_concepts",
tcav_dir=None,
nr_of_random_experiments=12,
concepts=[],
nr_imgs_per_concept=50,
nr_random_images=500):
# if no custom tcav dir is given, create one in the model directory
if tcav_dir == None:
tcav_dir = os.join(model.model_path, "tcav/")
# where activations are stored (only if your act_gen_wrapper does so)
activation_dir = os.path.join(tcav_dir, 'activations/')
# where CAVs are stored.
# You can say None if you don't wish to store any.
cav_dir = os.path.join(tcav_dir, 'cavs/')
utils.make_dir_if_not_exists(activation_dir)
utils.make_dir_if_not_exists(cav_dir)
# Folders that random iamges are stored in. These concept names are searched for Google image
# crawling, so choosing general/random terms lead to wide variety of images without preference
# for one concept
random_counterparts = ['random_images', 'photo', 'image']
crawl_and_process_concepts(concept_dir, concepts, random_counterparts,
nr_imgs_per_concept, nr_random_images)
'''
Create directories for random experiments. For each tcav random experiement, we
need on folder with random images. These directories are filled with 1/3 random
images from the random_counterpart folder and 2/3 are sampled from all concept
directories. This leads to random counterparts that do not favour one specific
concept.
'''
# name schema of the random concept directories, 'random500_' is the default
random_concept = "random500_"
other_concept_file_list = []
random_file_list = []
for dir in os.walk(concept_dir):
if dir[0] == concept_dir:
continue
if dir[0] in random_counterparts:
random_file_list += [os.path.join(dir[0], b) for b in dir[2]]
if "." in dir[0]:
continue
else:
other_concept_file_list += [
os.path.join(dir[0], b) for b in dir[2]
]
for index in range(0, nr_of_random_experiments):
random_out_dir = os.path.join(concept_dir, random_concept + str(index))
os.makedirs(random_out_dir)
file_list = []
file_list += random.sample(random_file_list, 33)
file_list += random.sample(other_concept_file_list, 67)
for infile in file_list:
if infile != '.DS_Store':
outfile = "-".join(infile.split("/")[2:])
im = Image.open(os.path.join(infile))
if im.mode not in ('RGBA', 'LA', 'P'):
im.save(os.path.join(random_out_dir, outfile), "JPEG")
def save_results(results, result_dir, name, random_counterpart=None, random_concepts=None, num_random_exp=100,
min_p_val=0.05):
"""Helper function to organize results.
When run in a notebook, outputs a matplotlib bar plot of the
TCAV scores for all bottlenecks for each concept, replacing the
bars with asterisks when the TCAV score is not statistically significant.
If you ran TCAV with a random_counterpart, supply it here, otherwise supply random_concepts.
If you get unexpected output, make sure you are using the correct keywords.
Args:
results: dictionary of results from TCAV runs.
random_counterpart: name of the random_counterpart used, if it was used.
random_concepts: list of random experiments that were run.
num_random_exp: number of random experiments that were run.
min_p_val: minimum p value for statistical significance
"""
utils.make_dir_if_not_exists(result_dir)
result_json = {
'concepts': []
}
# helper function, returns if this is a random concept
def is_random_concept(concept):
if random_counterpart:
return random_counterpart == concept
elif random_concepts:
return concept in random_concepts
else:
return 'random500_' in concept
# print class, it will be the same for all
print("Class =", results[0]['target_class'])
result_json['class'] = results[0]['target_class']
# prepare data
# dict with keys of concepts containing dict with bottlenecks
result_summary = {}
# random
random_i_ups = {}
for result in results:
if result['cav_concept'] not in result_summary:
result_summary[result['cav_concept']] = {}
if result['bottleneck'] not in result_summary[result['cav_concept']]:
result_summary[result['cav_concept']][result['bottleneck']] = []
result_summary[result['cav_concept']][result['bottleneck']].append(result)
# store random
if is_random_concept(result['cav_concept']):
if result['bottleneck'] not in random_i_ups:
random_i_ups[result['bottleneck']] = []
random_i_ups[result['bottleneck']].append(result['i_up'])
# to plot, must massage data again
plot_data = {}
plot_concepts = []
# print concepts and classes with indentation
for concept in result_summary:
# if not random
if not is_random_concept(concept):
print(" ", "Concept =", concept)
concept_json = {
'name': concept,
'bottlenecks': []
}
plot_concepts.append(concept)
for bottleneck in result_summary[concept]:
i_ups = [item['i_up'] for item in result_summary[concept][bottleneck]]
# Calculate statistical significance
_, p_val = ttest_ind(random_i_ups[bottleneck], i_ups)
if bottleneck not in plot_data:
plot_data[bottleneck] = {'bn_vals': [], 'bn_stds': [], 'significant': []}
if p_val > min_p_val:
# statistically insignificant
plot_data[bottleneck]['bn_vals'].append(0.01)
plot_data[bottleneck]['bn_stds'].append(0)
plot_data[bottleneck]['significant'].append(False)
else:
plot_data[bottleneck]['bn_vals'].append(np.mean(i_ups))
plot_data[bottleneck]['bn_stds'].append(np.std(i_ups))
plot_data[bottleneck]['significant'].append(True)
print(3 * " ", "Bottleneck =", ("%s. TCAV Score = %.2f (+- %.2f), "
"random was %.2f (+- %.2f). p-val = %.3f (%s)") % (
bottleneck, np.mean(i_ups), np.std(i_ups),
np.mean(random_i_ups[bottleneck]),
np.std(random_i_ups[bottleneck]), p_val,
"not significant" if p_val > min_p_val else "significant"))
concept_json['bottlenecks'].append({
'name': bottleneck,
'tcav_score_mean': np.mean(i_ups),
'tcav_score_std': np.std(i_ups),
'random_score_mean': np.mean(random_i_ups[bottleneck]),
'random_score_std': np.std(random_i_ups[bottleneck]),
'p_val': p_val,
'significant': not p_val > min_p_val
})
result_json['concepts'].append(concept_json)
# subtract number of random experiments
if random_counterpart:
num_concepts = len(result_summary) - 1
elif random_concepts:
num_concepts = len(result_summary) - len(random_concepts)
else:
num_concepts = len(result_summary) - num_random_exp
num_bottlenecks = len(plot_data)
bar_width = 0.35
# create location for each bar. scale by an appropriate factor to ensure
# the final plot doesn't have any parts overlapping
index = np.arange(num_concepts) * bar_width * (num_bottlenecks + 1)
# matplotlib
fig, ax = plt.subplots()
# draw all bottlenecks individually
for i, [bn, vals] in enumerate(plot_data.items()):
bar = ax.bar(index + i * bar_width, vals['bn_vals'],
bar_width, yerr=vals['bn_stds'], label=bn)
# draw stars to mark bars that are stastically insignificant to
# show them as different from others
for j, significant in enumerate(vals['significant']):
if not significant:
ax.text(index[j] + i * bar_width - 0.1, 0.01, "*",
fontdict = {'weight': 'bold', 'size': 16,
'color': bar.patches[0].get_facecolor()})
print (plot_data)
result_json['plot_data'] = plot_data
with open(os.path.join(result_dir, 'result.json'), 'w') as outfile:
json.dump(result_json, outfile, indent=4)
# set properties
ax.set_title('TCAV Scores for each concept and bottleneck')
ax.set_ylabel('TCAV Score')
ax.set_xticks(index + num_bottlenecks * bar_width / 2)
ax.set_xticklabels(plot_concepts)
ax.legend()
fig.tight_layout()
plt.savefig(os.path.join(result_dir, '{}.png'.format(name)))