Schwertlilien
归档分类标签关于
搜索
归档分类标签关于
Schwertlilien
As a recoder: notes and ideas.

2023.3.28

每天の学习日记论文阅读
版权声明: 署名-非商业性使用-禁止演绎 4.0
全文约1.8K字
阅读次数:

2023.3.28

U-GAT-IT

Unsupervised Generative Attentional networks

with adaptive layer-instance normalization(AdaLIN) for Image-to-Image Translation

  • The attention module:模型关注区分source domains and target domain(attention map)

  • New AdaLIN：自适应 层实例 归一化函数——control the amount of change in shape and texture(依据不同的数据集 改变函数的超参)

  • G:attention map–将注意力集中在两个领域(source domain&target domain)之间的特殊区别上。

  • D:attention map–helps fine-tuning(微调) BY 关注 target domain内fake图像和real图像之间的区别。

==归一化函数(normalization function)的选取影响the quality of the transformed results for various datasets(很多数据集的转换结果质量，这些数据集有着不同数量的在shape和texture上的改变)==

<受BIN批处理实例归一化的启发>，提出AdaLIN(自适应层实例归一化)

无监督生成网络

Goal：训练函数$G_{s\rightarrow t }$：from source domain $X_s$ to target domain $X_t$ (==unpaired sample==)

Frameworks：

  • Generators：$G_{s\rightarrow t}$，$G_{t\rightarrow s}$
  • Discriminators：$D_s$，$D_t$

Model($G_{s\rightarrow t}$)

$x\in {X_s,X_t}$：表示一个来自source & target domain的sample。

$G_{s\rightarrow t}=E_s+G_t+\eta_s$：encoder、decoder、auxiliary classifier(辅助分类器)。

$\eta_s(x)$：$x$来自$X_s$(source domain)的可能性。

$E_s^k(x)$：encoder的第k个activation map(激活映射)。

$E_s^{K_{ij}}(x)$：点$(i,j)$的值–承接上面$E_s^k(x)$，所以是encoder的第k个激活映射中点$(i,j)$的值。

$w_s^k$：第k个feature map(特征映射)的权值。==使用全局平均池化&全局最大池化（BY CAM）==
$$
\color{red}i.e.\color{black}\ \eta_s(x)=\sigma(\sum_k w_s^k\sum_{ij}E_s^{k_{ij}}(x))
$$
$a_s(x)$：domain specific attention feature map( $n$是encoder feature maps的数量 )
$$
a_s(x)=w_sE_s(x)={w_s^kE_s^k|1\le k\le n}
$$

==Translation Model：$G_{s\rightarrow t}=G_t(a_s(x))$==

AdaLIN

其参数$\gamma$和$\beta$将在一个来自attention map的全连接层进行动态计算。
$$
AdaLIN(\alpha,\gamma,\beta)=\gamma\ \cdot \ (\rho\ \cdot \hat{a_I}+(1-\rho)\ \cdot\ \hat{a_L})+\beta\
\hat{a_I}=\frac{a-\mu_I}{\sqrt{\sigma_I^2+\epsilon}}\
\hat{a_L}=\frac{a-\mu_L}{\sqrt{\sigma_L^2+\epsilon}}\
\rho\leftarrow clip_{[0,1]}(\rho-\tau \Delta \rho),\rho\in[0,1]
$$

  • $\mu_I,\mu_L$：channel-wise mean(通道), layer-wise mean(层)
  • $\sigma_I,\sigma_L$：channel-wise & layer-wise 标准差(standard deviation)
  • $\tau$：learning rate(学习速率)
  • $\Delta \rho$：更新向量的参数(BY 优化器optimizer)

$\rho$的值是在imposing bounds (Step:更新param)时被限制在[0,1]

G调整$\rho$值，$\rho$接近1时instance normalization很重要；$\rho$接近0时LN很重要。

$\rho$值在解码器的剩余块(redidual blocks)中初始化为1，在解码器的上采样块(up-sampling blocks)中初始化为0。

Discriminator

$x\in {X_t,G_{s\rightarrow t}(X_s)}$：来自目标域和翻译后的源域的示例。

$D_t=E_{D_t}+C_{D_t}+\eta_{D_t}$：$\eta_{D_t}(x)$ 和$D_t(x)$都被训练to分辨$x$来自$X_t$(target domain)还是$G_{s\rightarrow t}(X_s)$(从source domain生成的由source到target的映射，即fake images)

$\alpha_{D_t}(x)=w_{D_t}*E_{D_t}(x)$

==discriminator model：$D_t(x)=C_{D_t}(\alpha_{D_t}(x))$==

Loss function

包含以下四个损失函数：

  • Adversarial loss(对抗损失)：将转换后图像的分布与目标图像的分布进行匹配。
  • Cycle loss(返回原样损失)：to alleviate the mode collapse problem，因此施加周期约束——使得$x$从$X_s\rightarrow X_t$然后再$X_t\rightarrow X_S$能够恢复原样(original domain)。
  • Identify loss(标志一致约束)：保证输入图像与输出图像的颜色分布式是相似的。Given an image $x ∈ X_t$, after the translation of $x$ using $G_{s→t}$, the image should not change.
  • CAM loss(可提升损失)：给定一个来自${X_s,X_t}$的sample，$G_{s→t}$ and $D_t$ get to know where they need to improve or what makes the most difference between two domains in the current state.

$$
L_{lsgan}^{s\to t}=(E_{x\sim X_t}[(D_t(x))^2]+E_{x\sim X_s}[(1-D_t(G_{s\to t}(x)))^2])\
L_{cycle}^{s\to t}=E_{x\sim X_s}[|x-G_{t\to s}(G_{s\to t}(x))|1]\
L{identity}^{s\to t}=E_{x\sim X_t}[|x-G_{s\to t}(x)|1]\
L{cam}^{s\to t}=-(E_{x\sim X_s}[log(\eta_s(x))]+E_{x\sim X_t}[log(1-\eta_s(x))])\
L_{cam}^{D_t}=E_{x\sim X_t}[(\eta_{D_t}(x))^2]+E_{x\sim X_s}[1-\eta_{D_t}(G_{s\to t}(x))^2]\
$$

然后对它们联合起来一起训练：
$$
\min_{G_{s\to t},G_{t\to s},\eta_s,\eta_t}\ \max_{D_s,D_t,\eta D_s,\eta D_t}\lambda_1 L_{lsgan}+\lambda_2 L_{cycle}+\lambda_3 L_{identity}+\lambda_4 L_{cam}\
L_{lsgan}=L_{lsgan}^{s\to t}+L_{lsgan}^{t\to s}\ \ (same\ as\ L{cycle},L_{identity},L_{cam})\
\lambda_1=1,\lambda_2=10,\lambda_3=100,\lambda_4=1000\
$$

luogugu

P4017

给你一个食物网，你要求出这个食物网中最大食物链的数量。

（这里的“最大食物链”，指的是生物学意义上的食物链，即最左端是不会捕食其他生物的生产者，最右端是不会被其他生物捕食的消费者。）

Delia 非常急，所以你只有 $1$ 秒的时间。

由于这个结果可能过大，你只需要输出总数模上 $80112002$ 的结果。

P1177-快排

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <bits/stdc++.h>
using namespace std;

int n, num;
vector<int> vec;

int Partition(int l, int h) {
	int pviot = vec[l];
	while (l < h) {
		while (l < h && pviot <= vec[h]) h--;
		swap(vec[l], vec[h]);
		while (l < h && pviot >= vec[l]) l++;
		swap(vec[l], vec[h]);
	}
	return l;//返回中间：l=h,两边有序，确实不稳定
}

void QuickSort(int l, int h) {
	if (l < h) {
		int pviot = Partition(l, h);
		QuickSort(l, pviot - 1);
		QuickSort(pviot + 1, h);
	}
}

int main() {
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> num;
		vec.push_back(num);
	}

	QuickSort(0, n - 1);
	for (int i = 0; i < n; i++)
		cout << vec[i] << " ";
}

乐，本来由三个点T了。结果开完O2就A了，6.

真実に：いろいろのways。所以换一种板子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include<iostream>
using namespace std;
int n,a[1000001];
void qsort(int l,int r){//应用二分思想
    int mid=a[(l+r)/2];//中间数
    int i=l,j=r;
    do{
        while(a[i]<mid) i++;//查找左半部分比中间数大的数
        while(a[j]>mid) j--;//查找右半部分比中间数小的数
        if(i<=j){//如果有一组不满足排序条件（左小右大）的数
            swap(a[i],a[j]);//交换
            i++;//--|感觉可以不要
            j--;//--|
        }
    }while(i<=j);//这里注意要有=
    if(l<j) qsort(l,j);//递归搜索左半部分
    if(i<r) qsort(i,r);//递归搜索右半部分
}

int main(){
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    qsort(1,n);
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
}

话说Bucket这种排序我是没有接触过么？

那倒不是，只是又忘记了：类似Hash表做vector，然后每个vec[i]都是一个bucket.

搜索
匹配结果数:
未搜索到匹配的文章。