GANの学習方法が無限にあったので、比較してみた。

# GANの実装方法は多岐にわたる
先日kaggleの犬コンペに参加した時に、GANの実装方法が犬の数だけあって驚いたので、その中で個人的に気になった部分だけ比較して検証してみようと思います。

[kaggleの犬GANコンペ振り返り](https://qiita.com/akiraxakirax/items/9a5bc678774cda19b37c)

※ここではGANの説明はしません。詳しい記事は他の方がわかりやすく書いてくださっているので、御覧ください。
[GANについて概念から実装まで　～DCGANによるキルミーベイベー生成～](https://qiita.com/taku-buntu/items/0093a68bfae0b0ff879d)
[今さら聞けないGAN（1）　基本構造の理解](https://qiita.com/triwave33/items/1890ccc71fab6cbca87e)

# 初めに
GANの学習はとても難しいと言われていて、実際に私もコンペに出て実感しました。
最終的な精度云々ではなく、学習途中でlossが発散するなどしてしまい、それ以降はepochを重ねてもそこから向上しません。
GANの品質や多様性の改善と同じく**効率的な学習方法**についての論文も多く出てます。


下記の記事にてもっと役に立つ手法がいっぱいあります。
[GAN(Generative Adversarial Networks)を学習させる際の14のテクニック](https://qiita.com/underfitting/items/a0cbb035568dea33b2d7)
[GANで学習がうまくいかないときに見るべき資料](https://gangango.com/2018/11/16/post-322/)

[はじめてのGAN](https://elix-tech.github.io/ja/2017/02/06/gan.html)
>GANの仕組み

>GANではgeneratorとdiscriminatorという２つのネットワークが登場します。Generatorは訓練データと同じようなデータを生成しようとします。一方、discriminatorはデータが訓練データから来たものか、それとも生成モデルから来たものかを識別します。

>この関係は紙幣の偽造者と警察の関係によく例えられます。偽造者は本物の紙幣とできるだけ似ている偽造紙幣を造ります。警察は本物の紙幣と偽造紙幣を見分けようとします。

>次第に警察の能力が上がり、本物の紙幣と偽造紙幣をうまく見分けられるようになったとします。すると偽造者は偽造紙幣を使えなくなってしまうため、更に本物に近い偽造紙幣を造るようになります。警察は本物と偽造紙幣を見分けられるようにさらに改善し…という風に繰り返していくと、最終的には偽造者は本物と区別が付かない偽造紙幣を製造できるようになるでしょう。

>GANではこれと同じ仕組みで、generatorとdiscriminatorの学習が進んでいきます。最終的には、generatorは訓練データと同じようなデータを生成できるようになることが期待されます。このような状態では、訓練データと生成データを見分けることができなくなるため、discriminatorの正答率は50%になります。

上記の説明にもある通りG(generator)とD(discriminator)の２つのネットワークがそれぞれ敵対的(協力的？)に学習を進めていくところが「Generative Adversarial Networks」(GAN)と呼ばれる所以です。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/ae91a3e0-549a-1499-b6ff-91d0ac988f73.png)


この学習の進め方がほんとに色々あるのですが、その中でも気になった部分があります。

# lossを流すタイミング
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/a03305d6-6aac-c654-e1ce-9fc71ee65503.png)
[Goodfellow et al. (2014)](https://arxiv.org/abs/1406.2661)より引用


多くのGANの学習ステップとして多いのは

    1. 本物画像(real_image)をDに識別させてlossを計算する。
    2. 潜在変数zを乱数から作成し、Gにて(fake_image)を生成する。
    3. Dにて(fake_image)を識別させてlossを計算する。
    4. Dにreal,fakeのlossを同時に流す。
    5. 1と同様にfake_imageを再度作成する。
    6. Dに(fake_image)だけ判別をさせて、そのlossをGに流す。

このステップがおそらくGANの原文にもある通り、基本ステップだと思います。
これを**パターンA**とします。

基本的にはGANは**modelを通すタイミングがG,D合わせて5回**あります。
[Dの学習時] G_pred, D_fake, D_real
[Gの学習時] G_pred, D_fake

**lossを流すタイミングは3回**です。
[Dの学習時] D_fake, D_real
[Gの学習時] D_fake

lossを流した後に、modelを通したり、modelを全て通し終わった後にlossを流したり等いくつかパターンがありましたので、その違いを比較していきます。
細かい説明になってきますが、重要なのは**lossを流すタイミングとmodelを通すタイミング**です。

#### パターンB
    1. 潜在変数zを乱数から作成し、Gによって(fake_image)を生成する。
    2. Dにて(fake_image)のみ判別させて、**G**にlossを流す。
    3. 1と同様にfake_imageを再度作成する。
    4. Dによって(fake_image)と実際のデータ(real_image)を判別する。 
    5. それぞれlossを計算して、そのlossをDに同時に流す。

Dの学習→Gの学習の流れが逆転して**Gの学習→Dの学習**になったパターンです。
どっちも変わらない気がしますが、**先に学習するモデルの方が若干有利**になりそうです。
この場合、Gにlossが流れて**賢くなった後に**再度fake_imageを作成してDを騙すので、
**Dは精度が少し下がり**そうな気がします。
最終的な精度にどれだけ影響するかは不明ですが。

### パターンC
    1. 潜在変数zを乱数から作成し、Gによって(fake_image)を生成する。
    2. Dによって(real_image)のみ判別してDに(real_image)のlossを流す
    3. Dによって(fake_image)のみ判別してDに(fake_image)のlossを流す
    4. 1と同様にfake_imageを再度作成する。
    5. Dに(fake_image)だけ判別をさせて、そのlossをGに流す。

※2,3は逆転するパターンもあります。
Aと比較するとD_lossを流す際にfake,realを**「同時に流すか、片方ずつ流すか」**という違いがあります。
この場合は2でrealのみのlossを先に流しているので、**賢くなった後で**3のfake_imageの判別を行っています。
2で適切なlossが流れているとしたら、fake_imageの判別はAと比較してより正しい判断になります。
正しい判断になるということは**Dにlossが流れづらい**ということになります。

#### パターンD
    1. 潜在変数zを乱数から作成し、Gにて(fake_image)を生成する。
    2. Dにて(fake_image)と実際のデータ(real_image)を判別する。
    3. それぞれlossを計算しておくが、まだ流さない。
    4. 1と同様にfake_imageを再度作成する。
    5. Dに(fake_image)だけ判別をさせて、そのlossをGに流す。
    6. 3のlossをDにも流す。

このパターンはあまり見なかったのですが、個人的にはこれが一番フェアな気がします。
imageの作成やlossの計算はD,G共に全て終わらせてから、**D,G同時に勾配を流す**パターンです。
これならfake_image作成する際も、Dがreal,fakeの判別する際にもまだ勾配が流れていない状態なので、フェアです。
D,G同時に正解を知らされる感じです。
なんでこのパターンがあまり無いのか不明ですが、実装は簡単なので比較してみます。

何度も言いますが重要なポイントは**lossを流すタイミング**です。
**lossを流してからpredictをするのか、predictを全て終わらせてからlossを流すのか**という所の比較です。

また、上記のパターン意外にも色々あります。
DやGに複数回lossを流してみたりとか、条件付けをしてlossの数値が一定の値を超えた場合はlossを流すとか工夫がされてます。
とりあえずは上記パターンの違いが、どんな変化を生むかを検証してみます。
# 予想
大雑把にパターンの違いによる変化の予想をしてみます。
Aをベースラインとしてどうなるかという予想です。

| 予想|  Dの精度   |   loss|
|:-----------|-----:|------:|
| **B**      |下がる|  D↑G↓|
| **C**      |上がる|  D↓G↑|
| **D**      |下がる|  D↑G↓|

上記の説明をおさらいすると

- Bは**G_lossを先に流すのでGが有利**→Dの精度が下がる
- Cは**D_lossをfake,real別々に流すのでDが有利**→Dの精度が上がる
- DはAではD_lossを先に流してたものを、**D_loss,G_lossと同時にしたのでDが不利**→Dの精度が下がる

という様な推測です。
前半の推移は上記の予想に近い気はしますが、中盤以降の動きは全くどうなるかわかりません。
ましてや、最終的なスコアにどういった影響を与えるのかと言うのは更に予想がつきません。

# 実験

環境
- kaggleの犬ganコンペのコードを基本的には利用
- PyTorchを使用
- 比較数値としてD,Gのloss,Dの出力,FID(50epochごと),Inception_score(50epochごと)の推移を比較
- optimizerとして**RAdam**を使用
- kaggleのカーネルを使用して8.5時間回す
- inception_scoreはこちらの[コード](https://github.com/sbarratt/inception-score-pytorch)を使用
- FIDはkaggleから公式に配布されたコードを使用。

新しい物好きな性格と、スケジューラーの設定がめんどくさいということもあったので、
何故か**RAdam**を使用してます。
適切かどうかはわかりません笑

そして、基本的なパターンAのコードはこんな感じです。

```python
for itr, data in tqdm(enumerate(dataloader), total = len(dataloader)):
    #--------  Update Discriminator  ---------
    netD.zero_grad()    # Dの勾配を初期化
    output = netD(real_image)   # 本物画像をDに識別させる(1)
    errD_real = criterion(output, real_target)  # BCEloss 本物画像との誤差を計算(1)
    noise = torch.randn(sample_size, nz, 1, 1, device=device)   # 偽物画像の元(ノイズ)を作成(2)
    fake_image = netG(noise)    # 偽物画像を作成(2)
    output = netD(fake_image.detach())  # 偽物画像をDに識別させる(3)
    errD_fake = criterion(output, fake_target)  # 偽物画像の誤差を計算(3)
    errD = errD_real + errD_fake    # 2つの誤差を足し合わせる(4)
    errD.backward()    # Dに勾配を流す。(4)
    #---------  Update Generator   ----------
    netG.zero_grad()    # Gの勾配を初期化
    noise = torch.randn(sample_size, nz, 1, 1, device=device)   # 再度偽物画像の元(ノイズ)を作成(5)
    fake_image = netG(noise)    # 偽物画像を作成(5)
    output = netD(fake_image)   # 偽物画像をDに識別させる(6)
    errG = criterion(output, real_target)   # 偽物画像との誤差を計算(6)
    errG.backward()     # Gに勾配を流す。(6)
```

分かりやすくする為に色々端折ってますが、基本的にはこんな感じです。
文末の数字は上記で参照したパターンAのステップ数を表しています。

これらをそれぞれ4パターン回してみました。

## パターンBの考察
450エポック前後まで学習していましたが、D_outとlossの後半の推移はほとんど変わらなかったので150エポック位までで比較してます。
### D_out(左A,右B)
![epoch_doute.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/cd112d71-21d0-d8f5-86ca-0cf927de6517.png)<img width="359" alt="epoch_dout.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/9a2d2317-3b05-e744-2dee-e488e7357ba1.png">  

- 青がD_real
- オレンジはD学習時のD_fake
- 水色がG学習時のD_fake

※Dにはsigmoidが入っているので、**1に近ければreal**だと判断、**0に近ければfake**だと判断したとなります。
realとfakeの差が広ければ広いほど**Dの精度は良く**て相対的に**Gの精度は悪い**となります。
逆も然り
### loss(左A,右B)
![epoch_loss.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/52424d0b-37c5-1bd6-095c-ea0e44c119ab.png)<img width="341" alt="epoch_loss.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/13f07eef-2a0a-cac5-c91b-b397e8c796cd.png">

- オレンジはG_loss
- グレーはD_loss

**\<考察>**
Gが有利になり、Dの精度が下がると予想しましたが、**反対の結果**となりました。
最初の10エポック辺りでDに多めのlossが流れたことで、逆にDが賢くなったのかもしれません。
10エポック辺りでD_outのreal,fakeの差が急激に広がってます。
それによってG_lossも上昇して、D_lossは下がってます。
このG_lossの上昇がスコアにいい影響を与えてくれると良いんですが、どうなるでしょうか。

### inception_score(左A,右B)
![inception.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/07411617-a284-2b9d-374c-2cb19f9c9d54.png)<img width="373" alt="inception.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/7d064bbc-1f10-906a-f792-b1e728d5ffc6.png">
inceptionは高いほうがいい数字
### FID(左A,右B)
![fid.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/1bcef431-252f-1d77-1074-e32442298307.png)<img width="338" alt="fid.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/752fb9d6-587a-8d24-3a22-ed3391199a9c.png">
FIDは低い方がいい数字です。
**\<考察>**
lossやdoutは前半に少しの差異が見られただけで、後半はほぼ変わらなかったのですが、スコアは違いが見られます。
まず、**inception_scoreに関してはBの方が若干良い**です。
そして**FIDはBのほうが悪い。**
FIDは実画像の分布との差を図っていて、inceptionは画像自体の質と多様性を評価してるとのことです。
つまり今回は**画像自体の評価はパターンBの方が良いが、実画像により近いのはパターンA**ということだと思われます。
前半にG_lossが大きかったので良い画像を生成しているかと思いきや、そこまででもありませんでした。
FIDはギリギリ最後に追いついた感じはありますが、遅れています。
もう少し長めにやっていれば、更に変化が見られたかもしれません。
G_lossが多い分inception_scoreを上げることは出来たけど、Dの精度が低いのでFIDの改善は出来なかったのかもしれません。

## パターンCの考察

同様にAとの比較を行っていきます。
### D_out(左A,右C)
![epoch_doute.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/cd112d71-21d0-d8f5-86ca-0cf927de6517.png)<img width="379" alt="epoch_dout.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/e9775a2d-ff3c-4a59-efac-26df771d74e5.png">

### loss(左A,右C)
![epoch_loss.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/52424d0b-37c5-1bd6-095c-ea0e44c119ab.png)<img width="344" alt="epoch_loss.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/ce048c55-f411-a798-09f2-20bf19ed3bb2.png">

**\<考察>**
こちらも**予想が外れ**ました。
Aと比較して**Dの精度が悪い**です。
ただ、その後の**精度の改善スピード**は早く、後半はDが正しい判断が出来ています。
前半はDの精度が悪い為に、lossもDが高く、Gが低めです。
D_lossが多く流れたことから、結局Dがすぐに賢くなってGのlossがどんどん上がっていきます。
Dは学習が早いので、少しでも多めのlossを流すことでGが有利だったとしてもすぐに逆転されてしまう様な気がします。
### inception_score(左A,右C)
![inception.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/07411617-a284-2b9d-374c-2cb19f9c9d54.png)<img width="333" alt="inception.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/e2e121e1-b65e-94d0-0631-169c89073ea5.png">

### FID(左A,右C)
![fid.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/1bcef431-252f-1d77-1074-e32442298307.png)<img width="333" alt="FID.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/21792e38-1717-26fa-2dc2-75d3567b48c3.png">
**\<考察>**
inceptionに関しては初めの出だしは良かったもののその後の伸びが微妙です。
200エポック以降から更に一伸びあって、逆転しています。
150エポック以降にはG_lossが多く流れていき、inception_scoreを押し上げたかもしれません。
FIDはAほど下がりきりませんでした。

## パターンDの考察
ちょっと疲れたのと、よくわからない感じになったのでまとめて載せます。

### 左dout,右loss
![epoch_dout.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/db07ee9a-6332-bb52-f8ea-161b5c2f14ec.png)![epoch_loss.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/215f8d48-c385-7388-c41d-2422fea9075d.png)
### 左inception,右fid
![inception.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/f8ccdcda-6d57-62ee-3da5-0ff179a07e7a.png)![fid.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/465184/37641e15-62e6-209d-88c8-a762f1fbc083.png)
**\<考察>**
こちらはDの精度が悪くなる予想でしたが、**その通り**となりました。
ただ、想像以上に精度は悪くて、lossに関しては**G,Dが逆転**してます。
コードに何かしら不備があるかもしれません。
ただ、スコアだけを見るとそこまで大きな変化はありません。
スコアは改善に向かっていっているので、正常な気がします。
学習のバランスが崩れてしまっただけかもしれません。

# 総括
感想としては、予想以上に**大きな変化が出た**なという感覚です。
学習の順番等のタイミングを変えているだけで、lossの大きさ自体は操作していないのですが、それだけでここまで変化がありました。
**意図した通りの変化を与えることは難しく**て、ささいな変化が全体的なバランスを大きく変えてしまいます。
ここら辺がやっぱりGANが難しいと言われる所以でしょう。
感覚的に**Dは学習スピードが早い**ので、少しでも多くlossが流れるとGはすぐに逆転されてしまいます。
ただDの精度が上がらないと、Gに適切なlossが流れないということもあると思います。
結局どんな形のlossの推移がベストなのかは分からずじまいでしたが、学習が難しいということだけはわかりました。

あと、トータルで流れたlossの量も記録しておいたら良かった気がします。
lossの量によって、どんな影響を与えるのかというのも興味があります。

ちなみに素人の考察なので、間違っている部分は多くあるとおもいます。
もし、気づいたことなどあればコメントを頂けると勉強になって嬉しいです。
また、今回のパターンによる差異はどこまで有意かどうかはわかりません。
特にinceptionやFIDは50エポックに一回しか図っていないので、偶然差が出ただけかもしれません。
そこら辺はご理解くださいませ。

<details><summary>学習部分のコード</summary><div>

```python:train
fid_each_epoch = 50
rap_time_list = []
for epoch in range(n_epoch):
    epoch_start_time = time.time()
    if pattern == 'B' or 'D':
        for itr, data in tqdm(enumerate(dataloader), total = len(dataloader)):
            #---------  ラベル作成           ----------
            real_image = data.to(device)   # Real Images
            sample_size = real_image.size(0)  # The number of images
            real_target = torch.full((sample_size,), 1., device=device)   # real target
            fake_target = torch.full((sample_size,), 0., device=device)   # fake target

            #---------  Update Generator   ----------
            netG.zero_grad()    # initialize gradient
            noise = torch.randn(sample_size, nz, 1, 1, device=device)   # generate input noise         
            fake_image = netG(noise)    # fake images        
            output = netD(fake_image)   # Discriminator output for fake image
            errG = criterion(output, real_target)   # MSELoss
            D_G_z2 = output.mean().item()  # for logging
            if pattern != 'D':
                errG.backward()     # backward
                optimizerG.step()   # Updata Generator params
            #--------  Update Discriminator  ---------
            netD.zero_grad()    # initialize gradient
            output = netD(real_image)   # Discriminator output for real image
            errD_real = criterion(output, real_target)  # MSELoss
            D_x = output.mean().item()  # for logging
            noise2 = torch.randn(sample_size, nz, 1, 1, device=device)   # generate input noise             
            fake_image2 = netG(noise2)    # fake images
            output2 = netD(fake_image2.detach())  # Discriminator output for fake image
            errD_fake = criterion(output2, fake_target)  # MSELoss
            D_G_z1 = output2.mean().item()  # for logging
            if pattern == 'D':
                errG.backward()     # backward
                optimizerG.step()   # Updata Generator params            
            errD = errD_real + errD_fake    # Discriminator Loss
            errD.backward()    # backward
            optimizerD.step()   # Updata Discriminator params
            errg_list.append(errG.item())
            errd_list.append(errD.item())        
            dout_real.append(D_x)
            dout_fake1.append(D_G_z1)
            dout_fake2.append(D_G_z2)
            writer.add_scalars("data/loss_group", {'errD': errD.item(),
                                                   'errG': errG.item()}, epoch*len(dataloader)+itr)
            writer.add_scalars("data/dout_group", {'D_x': D_x,
                                                   'D_G_z1':D_G_z1,
                                                   'D_G_z2':D_G_z2}, epoch*len(dataloader)+itr)
            
    else:
        for itr, data in tqdm(enumerate(dataloader), total = len(dataloader)):
            real_image = data.to(device)   # Real Images
            sample_size = real_image.size(0)  # The number of images
            real_target = torch.full((sample_size,), 1., device=device)   # real target
            fake_target = torch.full((sample_size,), 0., device=device)   # fake target
            #--------  Update Discriminator  ---------
            netD.zero_grad()    # initialize gradient
            
            output = netD(real_image)   # Discriminator output for real image
            errD_real = criterion(output, real_target)  # MSELoss
            if pattern == 'C':
                errD_real.backward()
            D_x = output.mean().item()  # for logging
            noise = torch.randn(sample_size, nz, 1, 1, device=device)   # generate input noise             
            fake_image = netG(noise)    # fake images
            output = netD(fake_image.detach())  # Discriminator output for fake image
            errD_fake = criterion(output, fake_target)  # MSELoss
            if pattern == 'C':
                errD_fake.backward()
            D_G_z1 = output.mean().item()  # for logging
            errD = errD_real + errD_fake    # Discriminator Loss
            if pattern == 'A':
                errD.backward()    # backward
            optimizerD.step()   # Updata Discriminator params
            #---------  Update Generator   ----------
            netG.zero_grad()    # initialize gradient
            noise = torch.randn(sample_size, nz, 1, 1, device=device)   # generate input noise         
            fake_image = netG(noise)    # fake images        
            output = netD(fake_image)   # Discriminator output for fake image
            errG = criterion(output, real_target)   # MSELoss
            D_G_z = output.mean().item()  # for logging
            errG.backward()     # backward
            optimizerG.step()   # Updata Generator params
            errg_list.append(errG.item())
            errd_list.append(errD.item())        
            dout_real.append(D_x)
            dout_fake1.append(D_G_z1)
            dout_fake2.append(D_G_z2)       
            writer.add_scalars("data/loss_group", {'errD': errD.item(),
                                                   'errG': errG.item()}, epoch*len(dataloader)+itr)
            writer.add_scalars("data/dout_group", {'D_x': D_x,
                                                   'D_G_z1':D_G_z1,
                                                   'D_G_z2':D_G_z2}, epoch*len(dataloader)+itr)
    writer.add_scalars("data/epoch_loss_group", {'errD': np.mean(errd_list[epoch*len(dataloader):]),
                                                 "errG": np.mean(errg_list[epoch*len(dataloader):])}, epoch)
    writer.add_scalars("data/epoch_dout_group", {'D_x': np.mean(dout_real[epoch*len(dataloader):]),
                                                 "D_G_z1": np.mean(dout_fake1[epoch*len(dataloader):]),
                                                 "D_G_z2": np.mean(dout_fake2[epoch*len(dataloader):]),}, epoch)
    writer2.add_images('fake_images', fake_image[:10] * 0.5 + 0.5, global_step=epoch, walltime=None, dataformats='NCHW')
    rap_time = time.time() - epoch_start_time
    rap_time_list.append(rap_time)
    if epoch % fid_each_epoch == fid_each_epoch-1: # fid_each_epoch回数分、画像出力、loss、d_outプロット、画像を10000枚作成、FID計算まで行う。
        show_generated_img()
        outimg_path = '../output_images'+str(epoch)
        create_image(netG,nz=nz,threshold=1,fold_name=outimg_path,n_images=10000, im_batch_size=100)
        fid = fid_calc(outimg_path)
        inception_data = Inception_data(outimg_path+'/*')
        inc_mean, inc_std = inception_score(inception_data, cuda=True, batch_size=8, resize=True, splits=5)
        print('inception_score=',inc_mean)
        writer.add_scalars("data/score_group", {'fid': fid,
                                                "inception_score": inc_mean}, global_step=epoch)
    if time.time() - start_time > 60*60*8.5:
        break
```

</div>
</details>