SeqGANの実装にて、TypeError: __init__() got multiple values for argument 'g

前提・実現したいこと

以下のGithubのmain.ipynbに沿ってSeqGANの実装を進めています。
SeqGAN with keras
これを最後まで実行してSeqGANを実装したいと思っています。
しかし、順番通りに進めているのですが、途中でエラーが起きてしまいます。

発生している問題・エラーメッセージ

main.ipynbの指示通りに、以下のコードを入力してセルの実行をしました。

JupyterNotebook
1trainer = Trainer(B, T, g_E, g_H, d_E, d_filter_sizes, d_num_filters, d_dropout,
2    g_lr=g_lr, d_lr=d_lr, n_sample=n_sample, generate_samples=generate_samples)

Githubでは、これで上手く動いていました。
しかし、私がした時は以下のエラーが吐かれました。

TypeError                                 Traceback (most recent call last)
<ipython-input-56-7b876e170013> in <module>()
      1 trainer = Trainer(B, T, g_E, g_H, d_E, d_filter_sizes, d_num_filters, d_dropout,
----> 2     g_lr=g_lr, d_lr=d_lr, n_sample=n_sample, generate_samples=generate_samples)

TypeError: __init__() got multiple values for argument 'g_lr'

ソースコード

全て載せると膨大なので、init()の記述があるtrain.pyだけを載せておきます。
かと言って、このファイルに間違いがあるとは限りません。申し訳ありません。
他のコードはSeqGANフォルダにあります。

python
1from SeqGAN.models import GeneratorPretraining, Discriminator, Generator
2from SeqGAN.utils import GeneratorPretrainingGenerator, DiscriminatorGenerator
3from SeqGAN.rl import Agent, Environment
4from tensorflow.keras.optimizers import Adam
5import os
6import numpy as np
7import tensorflow as tf
8sess = tf.compat.v1.Session()
9import keras.backend as K
10K.set_session(sess)
11
12class Trainer(object):
13    '''
14    Manage training
15    '''
16    def __init__(self, B, T, g_E, g_H, d_E, d_H, d_dropout, g_lr=1e-3, d_lr=1e-3,
17        n_sample=16, generate_samples=10000, init_eps=0.1):
18        self.B, self.T = B, T
19        self.g_E, self.g_H = g_E, g_H
20        self.d_E, self.d_H = d_E, d_H
21        self.d_dropout = d_dropout
22        self.generate_samples = generate_samples
23        self.g_lr, self.d_lr = g_lr, d_lr
24        self.eps = init_eps
25        self.init_eps = init_eps
26        self.top = os.getcwd()
27        self.path_pos = os.path.join(self.top, 'data', 'kokoro_parsed.txt')
28        self.path_neg = os.path.join(self.top, 'data', 'save', 'generated_sentences.txt')
29        self.g_data = GeneratorPretrainingGenerator(
30            self.path_pos,
31            B=B,
32            T=T,
33            min_count=1)
34        if os.path.exists(self.path_neg):
35            self.d_data = DiscriminatorGenerator(
36                path_pos=self.path_pos,
37                path_neg=self.path_neg,
38                B=self.B,
39                shuffle=True)
40        self.V = self.g_data.V
41        self.agent = Agent(sess, B, self.V, g_E, g_H, g_lr)
42        self.g_beta = Agent(sess, B, self.V, g_E, g_H, g_lr)
43        self.discriminator = Discriminator(self.V, d_E, d_H, d_dropout)
44        self.env = Environment(self.discriminator, self.g_data, self.g_beta, n_sample=n_sample)
45
46        self.generator_pre = GeneratorPretraining(self.V, g_E, g_H)
47
48    def pre_train(self, g_epochs=3, d_epochs=1, g_pre_path=None ,d_pre_path=None,
49        g_lr=1e-3, d_lr=1e-3):
50        self.pre_train_generator(g_epochs=g_epochs, g_pre_path=g_pre_path, lr=g_lr)
51        self.pre_train_discriminator(d_epochs=d_epochs, d_pre_path=d_pre_path, lr=d_lr)
52
53    def pre_train_generator(self, g_epochs=3, g_pre_path=None, lr=1e-3):
54        if g_pre_path is None:
55            self.g_pre_path = os.path.join(self.top, 'data', 'save', 'generator_pre.hdf5')
56        else:
57            self.g_pre_path = g_pre_path
58
59        g_adam = Adam(lr)
60        self.generator_pre.compile(g_adam, 'categorical_crossentropy')
61        print('Generator pre-training')
62        self.generator_pre.summary()
63
64        self.generator_pre.fit_generator(
65            self.g_data,
66            steps_per_epoch=None,
67            epochs=g_epochs)
68        self.generator_pre.save_weights(self.g_pre_path)
69        self.reflect_pre_train()
70
71    def pre_train_discriminator(self, d_epochs=1, d_pre_path=None, lr=1e-3):
72        if d_pre_path is None:
73            self.d_pre_path = os.path.join(self.top, 'data', 'save', 'discriminator_pre.hdf5')
74        else:
75            self.d_pre_path = d_pre_path
76
77        print('Start Generating sentences')
78        self.agent.generator.generate_samples(self.T, self.g_data,
79            self.generate_samples, self.path_neg)
80
81        self.d_data = DiscriminatorGenerator(
82            path_pos=self.path_pos,
83            path_neg=self.path_neg,
84            B=self.B,
85            shuffle=True)
86
87        d_adam = Adam(lr)
88        self.discriminator.compile(d_adam, 'binary_crossentropy')
89        self.discriminator.summary()
90        print('Discriminator pre-training')
91
92        self.discriminator.fit_generator(
93            self.d_data,
94            steps_per_epoch=None,
95            epochs=d_epochs)
96        self.discriminator.save(self.d_pre_path)
97
98    def load_pre_train(self, g_pre_path, d_pre_path):
99        self.generator_pre.load_weights(g_pre_path)
100        self.reflect_pre_train()
101        self.discriminator.load_weights(d_pre_path)
102
103    def load_pre_train_g(self, g_pre_path):
104        self.generator_pre.load_weights(g_pre_path)
105        self.reflect_pre_train()
106
107    def load_pre_train_d(self, d_pre_path):
108        self.discriminator.load_weights(d_pre_path)
109
110
111    def reflect_pre_train(self):
112        i = 0
113        for layer in self.generator_pre.layers:
114            if len(layer.get_weights()) != 0:
115                w = layer.get_weights()
116                self.agent.generator.layers[i].set_weights(w)
117                self.g_beta.generator.layers[i].set_weights(w)
118                i += 1
119
120    def train(self, steps=10, g_steps=1, d_steps=1, d_epochs=1,
121        g_weights_path='data/save/generator.pkl',
122        d_weights_path='data/save/discriminator.hdf5',
123        verbose=True,
124        head=1):
125        d_adam = Adam(self.d_lr)
126        self.discriminator.compile(d_adam, 'binary_crossentropy')
127        self.eps = self.init_eps
128        for step in range(steps):
129            # Generator training
130            for _ in range(g_steps):
131                rewards = np.zeros([self.B, self.T])
132                self.agent.reset()
133                self.env.reset()
134                for t in range(self.T):
135                    state = self.env.get_state()
136                    action = self.agent.act(state, epsilon=0.0)
137                    next_state, reward, is_episode_end, info = self.env.step(action)
138                    self.agent.generator.update(state, action, reward)
139                    rewards[:, t] = reward.reshape([self.B, ])
140                    if is_episode_end:
141                        if verbose:
142                            print('Reward: {:.3f}, Episode end'.format(np.average(rewards)))
143                            self.env.render(head=head)
144                        break
145            # Discriminator training
146            for _ in range(d_steps):
147                self.agent.generator.generate_samples(
148                    self.T,
149                    self.g_data,
150                    self.generate_samples,
151                    self.path_neg)
152                self.d_data = DiscriminatorGenerator(
153                    path_pos=self.path_pos,
154                    path_neg=self.path_neg,
155                    B=self.B,
156                    shuffle=True)
157                self.discriminator.fit_generator(
158                    self.d_data,
159                    steps_per_epoch=None,
160                    epochs=d_epochs)
161
162            # Update env.g_beta to agent
163            self.agent.save(g_weights_path)
164            self.g_beta.load(g_weights_path)
165
166            self.discriminator.save(d_weights_path)
167            self.eps = max(self.eps*(1- float(step) / steps * 4), 1e-4)
168
169    def save(self, g_path, d_path):
170        self.agent.save(g_path)
171        self.discriminator.save(d_path)
172
173    def load(self, g_path, d_path):
174        self.agent.load(g_path)
175        self.g_beta.load(g_path)
176        self.discriminator.load_weights(d_path)
177
178    def test(self):
179        x, y = self.d_data.next()
180        pred = self.discriminator.predict(x)
181        for i in range(self.B):
182            txt = [self.g_data.id2word[id] for id in x[i].tolist()]
183            label = y[i]
184            print('{}, {:.3f}: {}'.format(label, pred[i,0], ''.join(txt)))

試したこと

Githubで使用されていたtensorflowのバージョンが1.10.0だったので、インストールが可能だった1.14.0で試してみたのですが、できませんでした。恐らくバージョンの問題ではないと思います。
コピペで進めていて、Githubと全く同じであるためタイプミスはありません。

どうか知恵をお貸しください。

補足情報（FW/ツールのバージョンなど）

現在、私が使用しているバージョン
・Python 3.7.11
・Keras 2.6.0
・tensorflow 2.6.0

Githubで使用しているバージョン
・Python 3.6.6
・Keras 2.2.2
・tensorflow 1.10.0

行動規範の内容に同意します

回答1件

d_filter_sizes, d_num_filters,
と
d_H,
で、
引き数の数が合っていません。

python
1Trainer     (      B, T, g_E, g_H, d_E, d_filter_sizes, d_num_filters, d_dropout, g_lr=g_lr, d_lr=d_lr, n_sample=n_sample, generate_samples=generate_samples)
2def __init__(self, B, T, g_E, g_H, d_E, d_H,                           d_dropout, g_lr=1e-3, d_lr=1e-3, n_sample=16,       generate_samples=10000,                   init_eps=0.1):