def setup(opts):
msg = '[SETUP] Ran with options: network = {}'
print(msg.format(opts['network']))
model = models.InceptionV1()
model.load_graphdef()
return model
def main():
model = models.InceptionV1()
model.load_graphdef()
img = load(
"https://storage.googleapis.com/lucid-static/building-blocks/examples/dog_cat.png"
)
act = ActivationGrid(model)
# very naive still takes some time to run
result = act.render_activation_grid_very_naive(img, W=48, n_steps=1024)
result = act.render_activation_grid_less_naive(img, W=48, n_steps=1024)
def __init__(self):
super(InceptionV1Model, self).__init__()
self._model = models.InceptionV1()
self._model.load_graphdef()
self._fprop_cache = dict()
self._scope_cache = dict()
x = self.make_input_placeholder()
self._default_input_placeholder = x
activation_maps = self.fprop(x)
self.activation_scores = {
layer: tf.math.reduce_max(activation_maps[layer], axis=[1, 2])
for layer in self.LAYERS
}
def __init__(self,
content,
overlap_px=10,
repeat=2,
num_strokes=5,
painter_type="GAN",
connected=True,
alternate=True,
bw=False,
learning_rate=0.1,
gpu_mode=True,
graph=None):
self.overlap_px = overlap_px
self.repeat = repeat
self.full_size = 64 * repeat - overlap_px * (repeat - 1)
self.unrepeated_num_strokes = num_strokes
self.num_strokes = num_strokes * self.repeat**2
self.painter_type = painter_type
self.connected = connected
self.alternate = alternate
self.bw = bw
print('full_size', self.full_size, 'max_seq_len', self.num_strokes)
self.content = content
self.inception_v1 = models.InceptionV1()
self.inception_v1.load_graphdef()
transforms = [
transform.pad(12, mode='constant', constant_value=.5),
transform.jitter(8),
transform.random_scale([1 + (i - 5) / 50. for i in range(11)]),
transform.random_rotate(list(range(-5, 5)) + 5 * [0]),
transform.jitter(4),
]
self.transform_f = render.make_transform_f(transforms)
self.optim = render.make_optimizer(
tf.train.AdamOptimizer(learning_rate), [])
self.gpu_mode = gpu_mode
if not gpu_mode:
with tf.device('/cpu:0'):
tf.logging.info('Model using cpu.')
self._build_graph(graph)
else:
#tf.logging.info('Model using gpu.')
self._build_graph(graph)
self._init_session()
def get_lucid_orig_image_losses(args):
#import lucid.modelzoo.vision_models as models
#model = models.InceptionV1()
#model.load_graphdef()
#param_f = lambda: param.image(128, batch=4)
#obj = objectives.channel("mixed5a", 9) - 1e2*objectives.diversity("mixed5a")
#obj = objectives.channel("mixed5a", 9)
#all_images = render.render_vis(model, obj, param_f)
#image = all_images[0]
global USE_ORG_IMPORT_MODEL
USE_ORG_IMPORT_MODEL = True
import lucid.modelzoo.vision_models as models
model = models.InceptionV1()
model.load_graphdef()
layer = "mixed5a"
num_units = 16
param_f = lambda: param.image(224, batch=num_units)
obj = objectives.channel(layer, 0, 0)
for idx in range(1, num_units):
obj += objectives.channel(layer, idx, idx)
image, all_losses = render_vis(model, obj, param_f)
return layer, image, all_losses
# Load output
# fne = np.load('fne.npy')
# fne_stats = np.load('stats.npy')
# Return
return features, stats
if __name__ == '__main__':
# This shows an example of calling the full_network_embedding method using
# the InceptionV1 architecture pretrained on ILSVRC2012 (aka ImageNet), as
# provided by the tensorflow lucid package. Using any other pretrained CNN
# model is straightforward.
# Load model
model = models.InceptionV1()
model.load_graphdef()
# Define input and target tensors
input_tensor = 'import/input:0'
target_tensors = ['import/mixed3a:0', 'import/mixed3b:0', 'import/mixed4a:0', 'import/mixed4b:0',
'import/mixed4c:0', 'import/mixed4d:0', 'import/mixed4e:0', 'import/mixed5a:0',
'import/mixed5b:0']
# Define images to process
image_paths = ['../images/img1.jpg', '../images/img2.jpg', '../images/img3.jpg']
batch_size = 2
input_reshape = (224, 224)
# Call FNE method
fne_features, fne_stats = full_network_embedding(model.graph_def, image_paths, batch_size, input_tensor,
import lucid.modelzoo.vision_models as models
from lucid.misc.io import show, load
from lucid.misc.io.showing import _image_url, _display_html
import sys
sys.path.insert(0, '../src')
# import unittest
from attribution import ChannelAttribution
model = models.InceptionV1() # this is GoogLeNet
model.load_graphdef()
def compare_attr_methods(attr, img, class1, class2):
_display_html("<h2>Linear Attribution</h2>")
attr.channel_attr(img, "mixed4d", class1, class2, mode="simple", n_show=10)
_display_html("<br><br><h2>Path Integrated Attribution</h2>")
attr.channel_attr(img, "mixed4d", class1, class2, mode="path", n_show=10)
_display_html("<br><br><h2>Stochastic Path Integrated Attribution</h2>")
attr.channel_attr(img,
"mixed4d",
class1,
class2,
mode="path",
n_show=10,
stochastic_path=True)
attr = ChannelAttribution(model)
}
def googlenet_spritemap(layer):
assert layer in layer_spritemap_sizes
size = layer_spritemap_sizes[layer]
url = "https://storage.googleapis.com/lucid-static/building-blocks/googlenet_spritemaps/sprite_%s_channel_alpha.jpeg" % layer
return size, url
model = chestnet()
model.load_graphdef()
print(model)
googlenet = models.InceptionV1()
googlenet.load_graphdef()
def googlenet_semantic_dict(layer, imgName):
img = PIL.Image.open(imgName)
img = img.resize((224, 224), PIL.Image.ANTIALIAS)
# Compute the activations
with tf.Graph().as_default(), tf.Session():
t_input = tf.placeholder(tf.float32, [224, 224, 3])
T = render.import_model(model, t_input, t_input)
acts = T(layer).eval({t_input: img})[0]
# Find the most interesting position for our initial view
def textureStyle3D(self):
print("Importing tensorflow...")
import tensorflow as tf
print("Checking that GPU is visible for tensorflow...")
if not tf.test.is_gpu_available():
raise Exception("No GPU available for tensorflow!")
print("Importing other libraries...")
import os
import io
import sys
from string import Template
from pathlib import Path
import numpy as np
import PIL.Image
# import matplotlib.pylab as pl
from IPython.display import clear_output, display, Image, HTML
# if os.name != 'nt':
# from lucid.misc.gl.glcontext import create_opengl_context
import OpenGL.GL as gl
from lucid.misc.gl import meshutil
from lucid.misc.gl import glrenderer
import lucid.misc.io.showing as show
import lucid.misc.io as lucid_io
from lucid.misc.tfutil import create_session
from lucid.modelzoo import vision_models
from lucid.optvis import objectives
from lucid.optvis import param
from lucid.optvis.style import StyleLoss, mean_l1_loss
from lucid.optvis.param.spatial import sample_bilinear
# if os.name != 'nt':
# print("Creating OpenGL context...")
# create_opengl_context()
gl.glGetString(gl.GL_VERSION)
print("Loading vision model...")
model = vision_models.InceptionV1()
model.load_graphdef()
def prepare_image(fn, size=None):
data = lucid_io.reading.read(fn)
im = PIL.Image.open(io.BytesIO(data)).convert('RGB')
if size:
im = im.resize(size, PIL.Image.ANTIALIAS)
return np.float32(im) / 255.0
self.loadCameras()
print("Loading input model from '{}'...".format(self.input_model_path))
mesh = meshutil.load_obj(self.input_model_path)
if self.cameras is None:
mesh = meshutil.normalize_mesh(mesh)
print("Loading input texture from '{}'...".format(
self.input_texture_path))
original_texture = prepare_image(
self.input_texture_path, (self.texture_size, self.texture_size))
print("Loading style from '{}'...".format(self.style_path))
style = prepare_image(self.style_path)
rendering_width = self.rendering_width
rendering_height = int(rendering_width // self.aspect_ratio)
print("Creating renderer with resolution {}x{}...".format(
rendering_width, rendering_height))
renderer = glrenderer.MeshRenderer((rendering_width, rendering_height))
if self.cameras is not None:
print(" renderer fovy: {:.2f} degrees".format(self.max_fovy))
renderer.fovy = self.max_fovy
sess = create_session(timeout_sec=0)
# t_fragments is used to feed rasterized UV coordinates for the current view.
# Channels: [U, V, _, Alpha]. Alpha is 1 for pixels covered by the object, and
# 0 for background.
t_fragments = tf.placeholder(tf.float32, [None, None, 4])
t_uv = t_fragments[..., :2]
t_alpha = t_fragments[..., 3:]
# Texture atlas to optimize
t_texture = param.image(self.texture_size, fft=True,
decorrelate=True)[0]
# Variable to store the original mesh texture used to render content views
content_var = tf.Variable(tf.zeros(
[self.texture_size, self.texture_size, 3]),
trainable=False)
# Sample current and original textures with provided pixel data
t_joined_texture = tf.concat([t_texture, content_var], -1)
t_joined_frame = sample_bilinear(t_joined_texture, t_uv) * t_alpha
t_frame_current, t_frame_content = t_joined_frame[
..., :3], t_joined_frame[..., 3:]
t_joined_frame = tf.stack([t_frame_current, t_frame_content], 0)
# Feeding the rendered frames to the Neural Network
t_input = tf.placeholder_with_default(t_joined_frame,
[None, None, None, 3])
model.import_graph(t_input)
# style loss
style_layers = [
sess.graph.get_tensor_by_name('import/%s:0' % s)[0]
for s in self.googlenet_style_layers
]
# L1-loss seems to be more stable for GoogleNet
# Note that we use style_decay>0 to average style-describing Gram matrices
# over the recent viewports. Please refer to StyleLoss for the details.
sl = StyleLoss(style_layers, self.style_decay, loss_func=mean_l1_loss)
# content loss
content_layer = sess.graph.get_tensor_by_name(
'import/%s:0' % self.googlenet_content_layer)
content_loss = mean_l1_loss(content_layer[0],
content_layer[1]) * self.content_weight
# setup optimization
total_loss = content_loss + sl.style_loss
t_lr = tf.constant(0.05)
trainer = tf.train.AdamOptimizer(t_lr)
train_op = trainer.minimize(total_loss)
init_op = tf.global_variables_initializer()
loss_log = []
def reset(style_img, content_texture):
del loss_log[:]
init_op.run()
sl.set_style({t_input: style_img[None, ...]})
content_var.load(content_texture)
def sample_random_view():
if self.cameras is None:
return meshutil.sample_view(10.0, 12.0)
else:
rand_m = self.cameras[np.random.randint(0, len(
self.cameras))]["transformToCamera"].copy()
return rand_m
def run(mesh, step_n=400):
app = QtWidgets.QApplication.instance()
for i in range(step_n):
fragments = renderer.render_mesh(
modelview=sample_random_view(),
position=mesh['position'],
uv=mesh['uv'],
face=mesh['face'])
_, loss = sess.run([train_op, [content_loss, sl.style_loss]],
{t_fragments: fragments})
loss_log.append(loss)
if i == 0 or (i + 1) % 50 == 0:
# clear_output()
last_frame, last_content = sess.run(
[t_frame_current, t_frame_content],
{t_fragments: fragments})
# show.images([last_frame, last_content], ['current frame', 'content'])
if i == 0 or (i + 1) % 10 == 0:
print(len(loss_log), loss)
pass
# Show progress
self.pBar.setValue(
(i + step_n // 10 + 1) / (step_n + step_n // 10) * 100)
app.processEvents()
reset(style, original_texture)
print("Running {} iterations...".format(self.steps_number))
run(mesh, step_n=self.steps_number)
print("Finished!")
texture = t_texture.eval()
print("Exporting result texture to '{}'...".format(
self.output_texture_path))
lucid_io.save(texture, self.output_texture_path, quality=90)
sess.close()
print("Importing result model to Metashape '{}'...".format(
self.result_model_path))
chunk.model = None
chunk.importModel(self.result_model_path)
chunk.model.label = self.style_name
Metashape.app.messageBox(
"Everything worked fine!\n"
"Please save project and RESTART Metashape!\n"
"Because video memory was not released by TensorFlow!")
def setup(opts):
model = models.InceptionV1()
model.load_graphdef()
return model
def main():
'''
Parse the arguments
'''
args = parse_args()
layer = args.layer
gpu = args.gpu
batch = args.batch
os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu)
googlenet = models.InceptionV1()
googlenet.load_graphdef()
nodes = googlenet.graph_def.node
# filenames = glob.glob('/media/fred/strawberry/imagenet-tf-records/*')
# filenames = glob.glob('test-images/imagenet-tf-records/*')
filenames = glob.glob('/raid/hpark407/imagenet-tf-records/*')
I_mat_dirpath = '/raid/fhohman3/I-mat/'
# chain_dirpath = './chain/'
num_class = 1000
all_layers = get_layers(nodes)
mixed_layers = [layer for layer in all_layers if 'mixed' in layer]
layers = {
'mixed3a': 256,
'mixed3b': 480,
'mixed4a': 508,
'mixed4b': 512,
'mixed4c': 512,
'mixed4d': 528,
'mixed4e': 832,
'mixed5a': 832,
'mixed5b': 1024
}
layer_fragment_sizes = {
layer: get_channel_sizes(layer, nodes)
for layer in mixed_layers
}
weight_sizes = get_weight_sizes(nodes, all_layers)
act_sizes = get_act_sizes(weight_sizes, mixed_layers)
k = 5
# chain_k = 3
mixed_layer = layer.split('_')[0]
prev_layer = get_prev_layer(all_layers, mixed_layer)
a_sz = act_sizes[mixed_layer]
f_sz = layer_fragment_sizes[mixed_layer]
frag_sz = [f_sz[0], f_sz[1], f_sz[2], f_sz[3], a_sz[1], a_sz[2]]
outlier_nodes = [
'mixed3a-67', 'mixed3a-190', 'mixed3b-390', 'mixed3b-399',
'mixed3b-412'
]
outlier_nodes_idx = [
int(n.split('-')[1]) for n in outlier_nodes if layer in n
]
# Get top impactful previous neurons and generate I-matrices
# Get layer info
is_mixed = '_' not in layer
branch = None if is_mixed else int(layer.split('_')[-1])
# Initialize I
num_channel = layers[layer] if is_mixed else act_sizes[layer[:-2]][branch]
I_layer = gen_empty_I(num_class, num_channel)
# Run
with tf.Graph().as_default():
# Get dataset
dataset = tf.data.TFRecordDataset(filenames)
dataset = dataset.map(_parse_function)
dataset = dataset.map(lambda img, lab, syn:
(preprocess_input(img), lab, syn))
dataset = dataset.batch(batch)
# Iterate tf-records
iterator = dataset.make_one_shot_iterator()
t_preprocessed_images, t_labels, t_synsets = iterator.get_next()
# Import googlenet
T = render.import_model(googlenet, t_preprocessed_images, None)
# Get weight tensors
t_w0, t_w1, t_w2, t_w3, t_w4, t_w5 = get_weight_tensors(mixed_layer)
# Get intermediate layer tensors
t_a0, t_a1, t_a2 = get_intermediate_layer_tensors(
prev_layer, mixed_layer)
# Define intermediate conv output tensors
t_inf_0 = get_infs(t_a0, t_w0)
t_inf_1 = get_infs(t_a1, t_w2)
t_inf_2 = get_infs(t_a2, t_w4)
t_inf_3 = get_infs(t_a0, t_w5)
t_inf_4 = get_infs(t_a0, t_w1)
t_inf_5 = get_infs(t_a0, t_w3)
# Run with batch
progress_counter = 0
with tf.Session() as sess:
start = time.time()
try:
with tqdm.tqdm(total=1281167, unit='imgs') as pbar:
while (True):
progress_counter += 1
# Run the session
if is_mixed:
labels, inf_0, inf_1, inf_2, inf_3 = sess.run(
[t_labels, t_inf_0, t_inf_1, t_inf_2, t_inf_3])
elif branch == 1:
labels, inf_4 = sess.run([t_labels, t_inf_4])
elif branch == 2:
labels, inf_5 = sess.run([t_labels, t_inf_5])
# Add up the counts
if is_mixed:
channel = 0
for frag, inf in enumerate(
[inf_0, inf_1, inf_2, inf_3]):
channel = update_I(layer, inf, channel,
I_layer, labels,
frag_sz[frag], k,
outlier_nodes_idx)
elif branch == 1:
update_I(layer, inf_4, 0, I_layer, labels,
frag_sz[4], k, outlier_nodes_idx)
elif branch == 2:
update_I(layer, inf_5, 0, I_layer, labels,
frag_sz[5], k, outlier_nodes_idx)
pbar.update(len(labels))
# print(inf_0.shape, inf_1.shape, inf_2.shape, inf_3.shape, inf_4.shape, inf_5.shape)
except tf.errors.OutOfRangeError:
pass
# Save I_layer
with open(I_mat_dirpath + 'I_%s.json' % layer, 'w') as f:
json.dump(I_layer, f, indent=2)
end = time.time()
print(end - start)
print(progress_counter)
print(progress_counter * batch)
def index():
# return 'Hello World!'
model = vision_models.InceptionV1()
model.load_graphdef()
TEXTURE_SIZE = 1024
mesh = meshutil.load_obj('article_models/bunny.obj')
mesh = meshutil.normalize_mesh(mesh)
original_texture = prepare_image('article_models/bunny.png',
(TEXTURE_SIZE, TEXTURE_SIZE))
style_url = 'https://upload.wikimedia.org/wikipedia/commons/d/db/RIAN_archive_409362_Literaturnaya_Gazeta_article_about_YuriGagarin%2C_first_man_in_space.jpg'
style = prepare_image(style_url)
renderer = glrenderer.MeshRenderer((512, 512))
googlenet_style_layers = [
'conv2d2',
'mixed3a',
'mixed3b',
'mixed4a',
'mixed4b',
'mixed4c',
]
googlenet_content_layer = 'mixed3b'
content_weight = 100.0
# Style Gram matrix weighted average decay coefficient
style_decay = 0.95
sess = create_session(timeout_sec=0)
# t_fragments is used to feed rasterized UV coordinates for the current view.
# Channels: [U, V, _, Alpha]. Alpha is 1 for pixels covered by the object, and
# 0 for background.
t_fragments = tf.placeholder(tf.float32, [None, None, 4])
t_uv = t_fragments[..., :2]
t_alpha = t_fragments[..., 3:]
# Texture atlas to optimize
t_texture = param.image(TEXTURE_SIZE, fft=True, decorrelate=True)[0]
# Variable to store the original mesh texture used to render content views
content_var = tf.Variable(tf.zeros([TEXTURE_SIZE, TEXTURE_SIZE, 3]),
trainable=False)
# Sample current and original textures with provided pixel data
t_joined_texture = tf.concat([t_texture, content_var], -1)
t_joined_frame = sample_bilinear(t_joined_texture, t_uv) * t_alpha
t_frame_current, t_frame_content = t_joined_frame[..., :3], t_joined_frame[
..., 3:]
t_joined_frame = tf.stack([t_frame_current, t_frame_content], 0)
# Feeding the rendered frames to the Neural Network
t_input = tf.placeholder_with_default(t_joined_frame,
[None, None, None, 3])
model.import_graph(t_input)
# style loss
style_layers = [
sess.graph.get_tensor_by_name('import/%s:0' % s)[0]
for s in googlenet_style_layers
]
# L1-loss seems to be more stable for GoogleNet
# Note that we use style_decay>0 to average style-describing Gram matrices
# over the recent viewports. Please refer to StyleLoss for the details.
sl = StyleLoss(style_layers, style_decay, loss_func=mean_l1_loss)
# content loss
content_layer = sess.graph.get_tensor_by_name('import/%s:0' %
googlenet_content_layer)
content_loss = mean_l1_loss(content_layer[0],
content_layer[1]) * content_weight
# setup optimization
total_loss = content_loss + sl.style_loss
t_lr = tf.constant(0.05)
trainer = tf.train.AdamOptimizer(t_lr)
train_op = trainer.minimize(total_loss)
init_op = tf.global_variables_initializer()
loss_log = []
reset(style, original_texture)
run(mesh)
texture = t_texture.eval()
return show.textured_mesh(mesh, texture)
def main():
# Import a model from the lucid modelzoo
# Or transform tensorflow slim model from https://github.com/tensorflow/models/tree/master/research/slim
# the lucid library help you download model automatically.
model = models.InceptionV1()
model.load_graphdef()
# labels_str = read("https://gist.githubusercontent.com/aaronpolhamus/964a4411c0906315deb9f4a3723aac57/raw/aa66dd9dbf6b56649fa3fab83659b2acbf3cbfd1/map_clsloc.txt")
# labels_str = labels_str.decode("utf-8")
# labels = [line[line.find(" "):].strip() for line in labels_str.split("\n")]
# labels = [label[label.find(" "):].strip().replace("_", " ") for label in labels]
# labels = ["dummy"] + labels
labels_str = read(model.labels_path)
labels_str = labels_str.decode("utf-8")
labels = [line for line in labels_str.split("\n")]
# layers = ["InceptionV1/Mixed_5c/concat", "InceptionV1/Mixed_5b/concat",
# "InceptionV1/Mixed_4f/concat", "InceptionV1/Mixed_4e/concat",
# "InceptionV1/Mixed_4d/concat", "InceptionV1/Mixed_4c/concat",
# "InceptionV1/Mixed_4b/concat", "InceptionV1/Mixed_3b/concat",
# "InceptionV1/Conv2d_2b_1x1/Relu", "InceptionV1/MaxPool_3a_3x3/MaxPool",
# ]
# layers = ["mixed5b", "mixed5a", "mixed4e", "mixed4d", "mixed4c",
# "mixed4b", "mixed4a", "mixed3b", "mixed3a", "maxpool1"]
# factorization_methods = ['DictionaryLearning', 'FactorAnalysis', 'FastICA', 'IncrementalPCA',
# 'LatentDirichletAllocation', 'MiniBatchDictionaryLearning',
# 'MiniBatchSparsePCA', 'NMF', 'PCA', 'SparsePCA',
# 'TruncatedSVD']
# factorization_methods = ['KernelPCA', 'SparseCoder', 'dict_learning', 'dict_learning_online', 'fastica']
layers = ["mixed4d"]
factorization_methods = ['FactorAnalysis']
# attr_classes = ['Egyptian cat', 'golden retriever']
# attr_classes = ['laptop', 'quilt'] # ['Labrador retriever', 'tennis ball', 'tiger cat']
# attr_classes = ['tiger cat', 'Labrador retriever']
# ('Labrador retriever', 'golden retriever')
# [11.319051 9.532383]
# ('Labrador retriever', 'golden retriever')
# [8.349452 8.214619 ]
attr_classes = ['golden retriever']
global_random_seed = 5
image_size = 224 # 224
# whether load the pre-computed feature attribution
flag_read_attr = True
# Shapley value computing method, "Shap" or "IGSG"
flag1 = "IGSG"
# iteration times for computing Shapley values
iter_num = 100
# pos_flag=1 means only compute positive Shapley
# = 2 means consider both positive and negative Shapley
pos_flag = 2
img_name = "./data/dog_cat224.jpg"
# ---------------------------------------------------------------------------------------------------
neuron_groups(img_name,
layers,
model,
attr_classes=attr_classes,
factorization_methods=factorization_methods,
flag1=flag1,
flag_read_attr=flag_read_attr,
iter_num=iter_num,
SG_path=False,
labels=labels,
pos_flag=pos_flag,
thres_explained_var=0.7,
vis_random_seed=global_random_seed,
image_size=image_size)
from scipy.misc import imsave
import tensorflow as tf
from lucid.modelzoo import vision_models
from lucid.misc.io import show, save, load
from lucid.optvis import objectives
from lucid.optvis import render
from lucid.misc.tfutil import create_session
from lucid.optvis.param import cppn
import lucid.optvis.param as param
from lucid.optvis.param import spatial, color, lowres
print ("Loading model")
model = vision_models.InceptionV1()
model.load_graphdef()
batch_size = 6
# Idea, after first training, try to reload the weights and only copy over the top layers...
# TESTED: size_n lower and lower training steps still works w/lower quality
#size_n = 200
#starting_training_steps = 2**10
size_n = 100
starting_training_steps = 2**9
#from skimage.transform import resize
#target_img = load("results/images/mixed4a_3x3_pre_relu_25.png")
def main():
googlenet = models.InceptionV1()
googlenet.load_graphdef()
sd = SemanticDict(googlenet)
sd.create_semantic_dict("mixed4d", "dog_cat.png")
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
import lucid.modelzoo.vision_models as model
from lucid.misc.io import show, load
from lucid.misc.io.reading import read
import lucid.optvis.objectives as objectives
import lucid.optvis.param as param
import lucid.optvis.render as render
import lucid.optvis.transform as transform
from lucid.misc.gradient_override import gradient_override_map
import cv2
model = model.InceptionV1()
model.load_graphdef()
# def raw_class_spatial_attr(img, layer, label, override=None):
# """How much did spatial positions at a given layer effect a output class?"""
#
# # Set up a graph for doing attribution...
# with tf.Graph().as_default(), tf.Session(), gradient_override_map(override or {}):
# t_input = tf.placeholder_with_default(img, [None, None, 3])
# T = render.import_model(model, t_input, t_input)
#
# # Compute activations
# acts = T(layer).eval()
#
# if label is None: return np.zeros(acts.shape[1:-1])
#
# # Compute gradient
