show_imgrid(
baddot_imgs_neg,
nrow=5,
padding=2,
)
save_imgrid(
baddot_imgs_neg,
join(savedir, "GAN_baddots_neg.png"),
nrow=5,
padding=2,
)
#%%
modelsnm = "StyleGAN2-Face512_Z"
savedir = join(saveroot, modelsnm)
os.makedirs(savedir, exist_ok=True)
SGAN = loadStyleGAN2("ffhq-512-avg-tpurun1.pt")
G = StyleGAN2_wrapper(SGAN)
H, eva, evc = load_Haverage("StyleGAN2-Face512_Z", descend=True)
randvec = G.sample_vector(10, 'cpu')
distnorm = randvec.norm(dim=1).mean().item()
# distnorm = np.sqrt(randvec.shape[1])
#%%
baddot_imgs_pos = G.visualize_batch_np(distnorm * evc[:, :20].T)
show_imgrid(
baddot_imgs_pos,
nrow=5,
padding=2,
)
save_imgrid(
baddot_imgs_pos,
join(savedir, "GAN_space_baddots_pos.png"),
import numpy as np
sys.path.append("E:\Github_Projects\Visual_Neuro_InSilico_Exp")
sys.path.append("D:\Github\Visual_Neuro_InSilico_Exp")
import os
# os.system(r"'C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvars64.bat'")
import lpips
try:
ImDist = lpips.LPIPS(net="squeeze").cuda()
except:
ImDist = lpips.PerceptualLoss(net="squeeze").cuda()
from GAN_hessian_compute import hessian_compute, get_full_hessian
from hessian_analysis_tools import compute_vector_hess_corr, compute_hess_corr, plot_layer_consistency_mat
from GAN_utils import loadStyleGAN2, StyleGAN2_wrapper
#%%
modelname = "ffhq-256-config-e-003810" # 109 sec
SGAN = loadStyleGAN2(modelname+".pt", size=256, channel_multiplier=1) # 491 sec per BP
#%%
L2dist_col = []
def Hess_hook(module, fea_in, fea_out):
print("hooker on %s"%module.__class__)
ref_feat = fea_out.detach().clone()
ref_feat.requires_grad_(False)
L2dist = torch.pow(fea_out - ref_feat, 2).sum()
L2dist_col.append(L2dist)
return None
feat = torch.randn(1, 512, requires_grad=True).cuda()
datadir = r"E:\OneDrive - Washington University in St. Louis\HessNetArchit\StyleGAN2"
for blocki in range(len(SGAN.convs)):
L2dist_col = []
torch.cuda.empty_cache()
from os.path import join
from time import time
import torch
import numpy as np
import matplotlib.pylab as plt
from GAN_utils import loadBigBiGAN, loadStyleGAN2, BigBiGAN_wrapper, StyleGAN2_wrapper, loadBigGAN, BigGAN_wrapper
# sys.path.append(r"/home/binxu/PerceptualSimilarity")
# sys.path.append(r"D:\Github\PerceptualSimilarity")
# sys.path.append(r"E:\Github_Projects\PerceptualSimilarity")
# import models
# ImDist = models.PerceptualLoss(model='net-lin', net='squeeze', use_gpu=1, gpu_ids=[0])
import lpips
ImDist = lpips.LPIPS(net="squeeze").cuda()
from GAN_hessian_compute import hessian_compute
#%%
SGAN = loadStyleGAN2("ffhq-512-avg-tpurun1.pt", size=512)
G = StyleGAN2_wrapper(SGAN)
#%% Accuracy dependency on the EPS value
feat = 0.5 * torch.randn(1, 512).detach().clone().cuda()
triali = 0
T0 = time()
eva_BP, evc_BP, H_BP = hessian_compute(G, feat, ImDist, hessian_method="BP")
print("%.2f sec" % (time() - T0)) # 2135.00 sec
H_col = []
for EPS in [1E-6, 1E-5, 1E-4, 1E-3, 1E-2, 1E-1, ]:
T0 = time()
eva_FI, evc_FI, H_FI = hessian_compute(G, feat, ImDist, hessian_method="ForwardIter", EPS=EPS)
print("%.2f sec" % (time() - T0)) # 325.83 sec
print("EPS %.1e Correlation of Flattened Hessian matrix BP vs ForwardIter %.3f" % (EPS, np.corrcoef(H_BP.flatten(), H_FI.flatten())[0, 1]))
H_col.append((eva_FI, evc_FI, H_FI))
T0 = time()
def shuffle_state_dict(SD, mask=lambda name: False):
shuffled_SD = {}
for name, Weight in SD.items():
if mask(name):
print("skip shuffling %s" % name)
shuffled_SD[name] = Weight
continue
else:
idx = torch.randperm(Weight.numel())
W_shuf = Weight.view(-1)[idx].view(Weight.shape)
shuffled_SD[name] = W_shuf
return shuffled_SD
#%%
SGAN = loadStyleGAN2('ffhq-512-avg-tpurun1.pt')
#%%
shuffled_SD = shuffle_state_dict(SGAN.state_dict())
#%%
torch.save(shuffled_SD,
join(datadir, "StyleGAN2_ffhq-512-avg-tpurun1_shuffle.pt"))
# print(name, Weight.shape, Weight.mean().item(), Weight.std().item())
#%%
SGAN_sf = loadStyleGAN2('ffhq-512-avg-tpurun1.pt')
SGAN_sf.load_state_dict(
torch.load(join(datadir, "StyleGAN2_ffhq-512-avg-tpurun1_shuffle.pt")))
G_sf = StyleGAN2_wrapper(SGAN_sf)
#%%
img = G_sf.visualize(torch.randn(1, 512).cuda()).cpu()
ToPILImage()(img[0, :].cpu()).show()
import numpy as np
from numpy.linalg import norm
import matplotlib.pylab as plt
from time import time
from os.path import join
from imageio import imwrite, imsave
from torchvision.transforms import ToPILImage
from torchvision.utils import make_grid
rootdir = r"E:\OneDrive - Washington University in St. Louis\Hessian_summary"
figsumdir = r"E:\OneDrive - Washington University in St. Louis\Hessian_summary\Figure7"
"""Note the loading and visualization is mostly deterministic, reproducible."""
#%% StyleGAN2 Face 1024
Hessdir = join(rootdir, 'StyleGAN2')
modelnm = "stylegan2-ffhq-config-f"
modelsnm = "Face1024"
SGAN2 = loadStyleGAN2(modelnm+".pt")
SG2 = StyleGAN2_wrapper(SGAN2)
with np.load(join(Hessdir, "H_avg_%s.npz"%modelnm)) as data:
eva_avg, evc_avg = data["eva_avg"], data["evc_avg"]#, data["feat_col"]
#%%
refvec = 0 * torch.randn(1, 512).cuda()
img = SG2.visualize(refvec)
ToPILImage()(make_grid(img).cpu()).show()
#%%
vis_eigen_frame(evc_avg, eva_avg, SG2, ref_code=refvec.cpu(), figdir=figsumdir, namestr="StyleGAN2_%s"%modelsnm, transpose=False,
eiglist=None, eig_rng=(0, 20), maxdist=0.0005, rown=5, sphere=False, )
#%%
from geometry_utils import LExpMap, SExpMap
) #nargs="+"
parser.add_argument('--range', type=int, default=[0, 80], nargs="+") #
args = parser.parse_args(
) #['--modelname', "ffhq-256-config-e-003810", "--fixed", "True"])
if sys.platform == "linux":
saveroot = r"/scratch/binxu/GAN_hessian/StyleGAN2"
else:
saveroot = r"E:\Cluster_Backup\StyleGAN2"
modelname = args.modelname # "model.ckpt-533504" # 109 sec
label = modelname + ("_W" if args.wspace else "") \
+ ("_fix" if args.fixed else "") \
+ ("_ctrl" if args.shuffled else "")
SGAN = loadStyleGAN2(modelname + ".pt")
G = StyleGAN2_wrapper(SGAN)
if args.wspace: G.use_wspace(True)
if args.fixed: G.random = False
if args.shuffled:
G.StyleGAN.load_state_dict(
torch.load(join(ckpt_root, modelname + "_shuffle.pt")))
istr, iend = args.range
savedir = join(saveroot, label)
os.makedirs(savedir, exist_ok=True)
print(savedir)
for triali in range(istr, iend):
feat = torch.randn(1, 512).detach().clone().cuda()
T0 = time()
eva_BP, evc_BP, H_BP = hessian_compute(
G,
import torch.nn.functional as F
from torchvision.transforms import ToPILImage
from torchvision.utils import make_grid
sys.path.append("E:\Github_Projects\Visual_Neuro_InSilico_Exp")
sys.path.append("D:\Github\Visual_Neuro_InSilico_Exp")
import lpips
try:
ImDist = lpips.LPIPS(net="squeeze").cuda()
except:
ImDist = lpips.PerceptualLoss(net="squeeze").cuda()
from GAN_hessian_compute import hessian_compute
from GAN_utils import loadStyleGAN2, StyleGAN2_wrapper
rootdir = r"E:\Cluster_Backup\StyleGAN2"
#%% Configurations for different checkpoints
modelname = "stylegan2-cat-config-f"
SGAN = loadStyleGAN2(modelname+".pt", size=256, channel_multiplier=2) #
modelname = "ffhq-256-config-e-003810" # 109 sec
SGAN = loadStyleGAN2(modelname+".pt", size=256, channel_multiplier=1) # 491 sec per BP
modelname = "ffhq-512-avg-tpurun1"
SGAN = loadStyleGAN2(modelname+".pt", size=512, channel_multiplier=2)
modelname = "stylegan2-ffhq-config-f"
SGAN = loadStyleGAN2(modelname+".pt", size=1024, channel_multiplier=2) # 491 sec per BP
modelname = "2020-01-11-skylion-stylegan2-animeportraits"
SGAN = loadStyleGAN2(modelname+".pt", size=512, channel_multiplier=2)
modelname = "stylegan2-car-config-f"
SGAN = loadStyleGAN2(modelname+".pt", size=512, channel_multiplier=2)
modelname = "model.ckpt-533504" # 109 sec
SGAN = loadStyleGAN2(modelname+".pt", size=512, channel_multiplier=2)
#%%
# for triali in range(1,16):
# feat = 0.5 * torch.randn(1, 512).detach().clone().cuda()
"id", "cc", "logcc", "reg_slop", "reg_intcp",
"reg_log_slop", "reg_log_intcp", "H_cc",
"logH_cc"
])
MSE_stat_tab.to_csv(join(savedir, "H_cmp_MSE_stat.csv"))
SSIM_stat_tab = pd.DataFrame(SSIM_stat_col,
columns=[
"id", "cc", "logcc", "reg_slop", "reg_intcp",
"reg_log_slop", "reg_log_intcp", "H_cc",
"logH_cc"
])
SSIM_stat_tab.to_csv(join(savedir, "H_cmp_SSIM_stat.csv"))
#%%
modelsnm = "Face256"
SGAN = loadStyleGAN2(
"ffhq-256-config-e-003810.pt",
size=256,
)
G = StyleGAN2_wrapper(SGAN, )
savedir = join(saveroot, "ImDist_cmp\\StyleGAN2\\Face256")
os.makedirs(savedir, exist_ok=True)
SSIM_stat_col = []
MSE_stat_col = []
for idx in range(100):
refvec = G.sample_vector(1, device="cuda") # 0.1 * torch.randn(1, 256)
eigvals_PS, eigvects_PS, H_PS = hessian_compute(G,
refvec,
ImDist,
hessian_method="BP")
eigvals_SSIM, eigvects_SSIM, H_SSIM = hessian_compute(G,
refvec,
D,
#%% """StyleGAN2"""
Hessdir = join(rootdir, 'StyleGAN2')
modellist = [
"ffhq-256-config-e-003810", "ffhq-512-avg-tpurun1",
"stylegan2-cat-config-f", "2020-01-11-skylion-stylegan2-animeportraits",
"model.ckpt-533504", "stylegan2-ffhq-config-f", "stylegan2-car-config-f"
]
modelsnms = [
"Face256", "Face512", "Cat256", "Anime", "ImageNet512", "Face1024",
"Car512"
]
#%%
for modelnm, modelsnm in zip(modellist[6:], modelsnms[6:]):
# modelnm, modelsnm = modellist[1], modelsnms[1]
SGAN = loadStyleGAN2(modelnm + ".pt") # , size=256
SG = StyleGAN2_wrapper(SGAN)
figdir = join(axesdir, "StyleGAN2", modelsnm)
os.makedirs(figdir, exist_ok=True)
data = np.load(
join(Hessdir, "H_avg_%s.npz" % modelnm)
) #, H_avg=H_avg, eva_avg=eva_avg, evc_avg=evc_avg, feats=feat_col)
H_avg = data["H_avg"]
eva_avg = data["eva_avg"]
evc_avg = data["evc_avg"]
#%
RND = np.random.randint(1E4)
ref_codes = 0.7 * np.random.randn(8, 512)
for eigidx in range(40):
vis_eigen_action(evc_avg[:, -eigidx - 1],
ref_codes,
from glob import glob
import sys
import pandas as pd
import numpy as np
from hessian_analysis_tools import scan_hess_npz, plot_spectra, average_H, compute_hess_corr, plot_consistency_example
from hessian_axis_visualize import vis_eigen_explore, vis_eigen_action, vis_eigen_action_row, vis_eigen_explore_row
from GAN_utils import loadStyleGAN2, StyleGAN2_wrapper, loadBigGAN, BigGAN_wrapper
import matplotlib.pylab as plt
import matplotlib
summarydir = r"E:\OneDrive - Washington University in St. Louis\Hessian_summary"
#%%
dataroot = "E:\\Cluster_Backup\\StyleGAN2"
modelnm = "stylegan2-cat-config-f"
modelsnm = "Cat256"
SGAN = loadStyleGAN2(
modelnm + ".pt",
size=256,
)
SG = StyleGAN2_wrapper(SGAN, )
eigval_col, eigvec_col, feat_col, meta = scan_hess_npz(join(dataroot, modelnm),
"Hess_BP_(\d*).npz",
featkey="feat")
feat_col = np.array(feat_col).squeeze()
# H_avg, eva_avg, evc_avg = average_H(eigval_col, eigvec_col)
# np.savez(join(Hessdir, "H_avg_%s.npz"%modelnm), H_avg=H_avg, eva_avg=eva_avg, evc_avg=evc_avg, feats=feat_col)
#%%
vis_eigen_action_row(
eigvec_col[0],
feat_col[0, :],
maxdist=120,
rown=7,
)
import torch
import torch.optim as optim
import torch.nn.functional as F
from torchvision.transforms import ToPILImage, ToTensor
from hessian_eigenthings.power_iter import Operator, deflated_power_iteration
from hessian_eigenthings.lanczos import lanczos
from lanczos_generalized import lanczos_generalized
from GAN_hvp_operator import GANHVPOperator, GANForwardHVPOperator, compute_hessian_eigenthings, get_full_hessian
import sys
import numpy as np
import matplotlib.pylab as plt
from time import time
from os.path import join
from imageio import imwrite
from build_montages import build_montages, color_framed_montages
import torchvision.models as tv
from GAN_utils import loadStyleGAN2, StyleGAN2_wrapper, ckpt_root
g_ema = loadStyleGAN2("stylegan2-cat-config-f.pt")
G = StyleGAN2_wrapper(g_ema)
#%%
paramnum = 0
for name, param in g_ema.state_dict().items():
paramnum += np.prod(param.shape)
for name, param in g_ema.state_dict().items():
print(name, list(param.shape), "%.1f%%"%(100*np.prod(param.shape) / paramnum))
#%%
#%%
imgs_PCs = G.visualize_batch_np(-evc[:, -25:].T)
ToPILImage()(make_grid(imgs_PCs)).show()
#%%
corrmat1 = 1 - cdist(PCregaxes, evc[:, -25:].T, metric="correlation")
#%%
unitPCregaxes = PCregaxes / np.linalg.norm(PCregaxes, axis=1, keepdims=True)
#%%
proj_coef = unitPCregaxes @ evc[:,::-1]
plt.plot(proj_coef.T**2)
plt.show()
#%%
ccmat1 = abs(1 - cdist(unitPCregaxes, evc[:, -30:].T, metric="cosine"))
plt.figure()
plt.matshow(ccmat1,0)
plt.ylabel("Hessian eigenvector")
plt.xlabel("PC regress axes")
cbar = plt.colorbar()
cbar.ax.set_ylabel("abs(cosine)")
plt.show()
#%%
ccmat2 = 1 - cdist(PCWeiAvg, evc[:, -30:].T, metric="correlation")
#%%
#%%
SGAN = loadStyleGAN2()
G = StyleGAN2_wrapper(SGAN)
