Implicit-Competitive-Regularization - GitLite

KO | EN

gitlite — search

#javascript #hacktoberfest #react #rust #deep-learning #linux #docker #java #cli #awesome-list #pytorch #ios #openai #open-source

Implicit-Competitive-Regularization

(★ 116)

Code for: Implicit Competitive Regularization in GANs

File Explorer

Download Latest Version (.zip)

- dataset_utils.py
- download_ffhq.py
- ffhq_download.sh
- ffhq_make_data.sh
- lsun_download.py
- lsun_download.sh
- lsun_make.py
- lsun_make_data.sh
- prepare_data.py
- - __init__.py
  - fused_act.py
  - fused_bias_act.cpp
  - fused_bias_act_kernel.cu
  - upfirdn2d.cpp
  - upfirdn2d.py
  - upfirdn2d_kernel.cu
- __init__.py
- cifar_models.py
- cifar_resnet.py
- dcgan.py
- layers.py
- models.py
- sngans.py
- styleganv2.py
- __init__.py
- cifar10.py
- fid_score.py
- inception.py
- inception_pt.py
- inception_tf13.py
- InceptionScore_tf2.py
- is_biggan.py
- lsun_bedroom.py
- __init__.py
- acgd.py
- acgd2.py
- adam.py
- cgd.py
- cgd_utils.py
- icr.py
- lcgd.py
- ocgd.py
- scg.py
- scg_utils.py
- scgd.py
- testOptim.py
- - DCGAN.yaml
  - ResnetGAN.yaml
- cal_celeba_stats.sh
- cal_cifar_stats.sh
- cal_lsun_stats.sh
- cal_mnist_stats.sh
- eval_pt-celeba-dc.sh
- eval_pt-cifar10-dc.sh
- eval_pt-lsun-fid-wgp.sh
- stylegan-ffhq-acgd.sh
- stylegan-ffhq-adam.sh
- cgd_test.py
- cgTest.py
- checkBackprop.py
- ICR_test.py
.gitignore
adatrain_stylegan_cgd.py
cal_flops.py
calculate_stats.py
cgd_stochastic.py
distributed.py
eval_pt.py
eval_tf.py
eval_tf2.py
generate_images.py
LICENSE
losses.py
mnist_adam.py
non_leaking.py
pretrain_discriminator.py
README.md
train_oneside.py
train_seq.py
train_simul.py
train_stylegan.py
train_stylegan_cgd.py
train_utils.py
utils.py
wgan_gp.py

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

<h1 align="center">Implicit competitive regularization in GANs</h1>

This code contains experiments for our ICML paper: [Implicit competitive regularization in GANs](http://proceedings.mlr.press/v119/schaefer20a.html).
## For competitive optimization

Optimizers in this package are for competitive optimization problems, given by 
$$
\min_{x}\max_{y} f(x,y)
$$

### Install through pip

`pip install CGDs`

See details at CGDs package: [CGDs · PyPI](https://pypi.org/project/CGDs/).

You can also directly copy the folder 'optims' to your workspace.

## How to use

The package contains the original Compeititive Gradient Descent (BCGD), and the Adaptive Competitive Gradient Descent (ACGD).

Quickstart with notebook: [Examples of using ACGD](https://colab.research.google.com/drive/1-52aReaBAPNBtq2NcHxKkVIbdVXdyqtH?usp=sharing).

**It's important to force cudnn to benchmark and pick the best algo.**

Check more details at [cgds-package: Package for CGD and ACGD optimizers ](https://github.com/devzhk/cgds-package).

```python
import torch
torch.backends.cudnn.benchmark = True
from CGDs import ACGD
device = torch.device('cuda:0')
lr = 0.0001
G = Generator()
D = Discriminator()
optimizer = ACGD(max_params=G.parameters(), min_params=D.parameters(), lr_max=lr, lr_min=lr, device=device)
# max_parems is maximizing the objective function while the min_params is trying to minimizing it. 
# BCGD(max_params=G.parameters(), min_params=D.parameters(), lr_max=lr, lr_min=lr, device=device)
# ACGD: Adaptive CGD;
for img in dataloader:
    d_real = D(img)
    z = torch.randn((batch_size, z_dim), device=device)
    d_fake = D(G(z))
    loss = criterion(d_real, d_fake)
    optimizer.zero_grad()
    optimizer.step(loss=loss)
```
==**Warning**==:

1. **zero sum** game setting only. This implementation uses conjugate gradient method to solve matrix inversion efficiently, which requires the matrix to be positive definite. If you are using competitive gradient descent (CGD) algorithm for non-zero sum games, please check more details in CGD paper https://arxiv.org/abs/1905.12103. For example, GMRES (the generalized minimal residual) algorithm can be a solver for non-zero sum setting. 
2. This implementation doesn't work with torch.nn.parallel.DistributedDataParallel module because we need autograd.grad() to compute Hessian vector product. See details at [DDP doc]([DistributedDataParallel — PyTorch 1.7.0 documentation](https://pytorch.org/docs/stable/generated/torch.nn.parallel.DistributedDataParallel.html)) .

## Citation
Please cite the following paper if you find this code useful. Thanks!
```
@misc{schfer2019implicit,
    title={Implicit competitive regularization in GANs},
    author={Florian Schäfer and Hongkai Zheng and Anima Anandkumar},
    year={2019},
    eprint={1910.05852},
    archivePrefix={arXiv},
    primaryClass={cs.LG}
}
```