[CVPR2021] Image-to-image Translation via Hierarchical Style Disentanglement 代码学习记录

数据预处理 preprocessors

（1）os.path.join(xx, xxxx) 会自动在你要连接的两个路径中加入/
（2）os.makedirs
　　　看这一篇
（3）line的结构：

train

（1）os.path.splitext() 将文件名和扩展名分开
　　用到os.path.basename(),返回path最后的文件名。若path以/或\结尾，那么就会返回空值。
eg:

path='D:\CSDN'
os.path.basename(path)=CSDN

（2）python shutil.copy()用法

shutil.copyfile(src, dst)：复制文件内容（不包含元数据）从src到dst。
DST必须是完整的目标文件名;
如果src和dst是同一文件，就会引发错误shutil.Error。
dst必须是可写的，否则将引发异常IOError。如果dst已经存在，它会被替换。
特殊文件，例如字符或块设备和管道不能使用此功能，因为copyfile会打开并阅读文件。
src和dst的是字符串形式的路径名。

(3) Python strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列。
Python rstrip() 删除 string 字符串末尾的指定字符（默认为空格）
split() 按照空格分割开字符串，分割以后是一个list
[‘E:\Workspaces\A\HiSD-main\data\imgs\3027.jpg’, ‘1’, ‘1’]
（4）dataloader

data_prefetcher是一个类， 意思是把dataloader里面的数据取出来，变成x，y（tensor）的形式，然后放到cuda上去吗？
然后类定义了一个函数，next()，对这个类的实例进行迭代，就可以取出x（图片），y（两个无关条件）
然后iter是把他们变成列表的形式整合起来吗

tags的具体值

train_iter:

（5）关于*arg和**arg
小小总结一下：就是这两种形式
*args:
mydict(1,2,3,4)
**args:
mydict = dict(system=“系统”, China=“中国”, link=“联接”)

#*args的用法：当传入的参数个数未知，且不需要知道参数名称时。
def func_arg(farg, *args):
    print("formal arg:", farg)
    for arg in args:
        print("another arg:", arg)
func_arg(1,"youzan",'dba','四块五的妞')
print("-----------------------")

# 输出结果如下：
# formal arg: 1
# another arg: youzan
# another arg: dba
# another arg: 四块五的妞
# -----------------------

#**args的用法：当传入的参数个数未知，但需要知道参数的名称时(立马想到了字典，即键值对)
def func_kwargs(farg, **kwargs):
    print("formal arg:", farg)
    for key in kwargs:
        print("keyword arg: %s: %s" % (key, kwargs[key]))
func_kwargs(1 ,id=1, name='youzan', city='hangzhou',age ='20',四块五的妞是 = '来日方长的')
print('--------------------')

# 输出结果如下：
# formal arg: 1
# keyword arg: id: 1
# keyword arg: name: youzan
# keyword arg: city: hangzhou
# keyword arg: age: 20
# keyword arg: 四块五的妞是: 来日方长的
#利用它转换参数为字典
def kw_dict(**kwargs):
    return kwargs
print(kw_dict(a=1,b=2,c=3))
# 输出结果如下：
# --------------------
# {'a': 1, 'b': 2, 'c': 3}

（6）对于梯度爆炸的处理方法，见此链接
https://www.jianshu.com/p/642b50ca5d91
（7）页面太小的问题，方法三亲测可用
https://blog.csdn.net/weixin_43959833/article/details/116669523
（8） 对于x.view()和x.repeat()

  x = x.view(x.size(0), -1, 1, 1)
    #改变大小，变成 batchsize，-1,1,1
    x = x.repeat(1, 1, target.size(2), target.size(3))
    #对第二、三个通道复制target.size(2)次和target.size(3)次，其余保持不变

（9）Gen损失函数

loss_gen_adv = self.dis.calc_gen_loss_real(x, s, y, i, j) + \
                     self.dis.calc_gen_loss_fake_trg(x_trg, s_trg.detach(), y, i, j_trg) + \
                     self.dis.calc_gen_loss_fake_cyc(x_cyc, s.detach(), y, i, j) 

对应于图片中的三个小框框

但是说实话，我这边不太理解啊，就是discriminator这儿

    def calc_gen_loss_real(self, x, s, y, i, j):#计算他是真实图片的分数？？
        loss = 0
        out = self.forward(x, s, y, i)[:, :, j]#选到那个属性
        #比如是[8, 2, 2], 截取[:,:,1] 就变成了[8, 2]了
        loss += out[:, 0].mean()
        loss += out[:, 1].mean()
        return loss

    def calc_gen_loss_fake_trg(self, x, s, y, i, j):
        out = self.forward(x, s, y, i)[:, :, j]
        loss = - out[:, 0].mean()
        return loss

    def calc_gen_loss_fake_cyc(self, x, s, y, i, j):
        out = self.forward(x, s, y, i)[:, :, j]
        loss = - out[:, 1].mean()
        return loss

看不懂为啥真实图片取0,1维度，fake图片，一个取0维度，一个取1维度

（10）关于鉴别器，作者给出的解释，见链接添加链接描述
补充一些先验知识：
原图+图和条件匹配->高分
原图+图和条件不匹配->低分
人工图->低分
（11）浅拷贝与深拷贝
浅拷贝：当我们在 Python 中使用赋值语句 (=) 来创建复合对象的副本时，例如，列表或类实例或基本上任何包含其他对象的对象，Python 并没有克隆对象本身。
相反，它只是将引用绑定到目标对象上。
深拷贝：深度复制一个对象意味着真正地将该对象和它的值克隆到内存中的一个新的副本（实例）中，并具有这些相同的值。
（12）更好地了解鉴别器：

class Dis(nn.Module):
    def __init__(self, hyperparameters):
        super().__init__()
        self.tags = hyperparameters['tags']
        channels = hyperparameters['discriminators']['channels']
        #[64, 128, 256, 512, 1024, 2048]
        self.conv = nn.Sequential(
            nn.Conv2d(hyperparameters['input_dim'], channels[0], 1, 1, 0),
            *[DownBlock(channels[i], channels[i + 1]) for i in range(len(channels) - 1)],
            nn.AdaptiveAvgPool2d(1),
        )

        self.fcs = nn.ModuleList([nn.Sequential(
            nn.Conv2d(channels[-1] + #2048
            hyperparameters['style_dim'] + #256
            self.tags[i]['tag_irrelevant_conditions_dim'], #2 2 2
            # One for translated, one for cycle. Eq.4
            len(self.tags[i]['attributes'] * 2), 1, 1, 0), #4 4 6
        ) for i in range(len(self.tags))])

    def forward(self, x, s, y, i):
        f = self.conv(x)
        print("x.shape:", x.shape)
        print("s.shape:", s.shape)
        print("y.shape:", y.shape)
        fsy = torch.cat([f, tile_like(s, f), tile_like(y, f)], 1)
        print("f.shape:", f.shape)
        print("after title_like and cat:")
        print("s.shape:", tile_like(s, f).shape)
        print("y.shape:", tile_like(y, f).shape)
        print("fsy.shape:", fsy.shape)
        b = self.fcs[i](fsy).view(f.size(0), 2, -1)
        print(b.shape)
        return self.fcs[i](fsy).view(f.size(0), 2, -1)