複素数の型を定義したい

前提・実現したいこと

Affine layerに複素数を実装したところ型についてのエラーが発生しました。どこを修正したら良いのかわからないのでご教示いただきたいです。関係のある箇所を抜き出しているのでコードが少し長くなっていますのでご了承ください。
参考として　https://ebi-works.com/deeplearning-6/ のコードを使用しています。

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

  # パラメータの更新
     34     for key in ('W1', 'b1', 'W2', 'b2'):
---> 35         network.params[key] -= learning_rate * grad[key]
     36 
     37     loss = network.loss(x_batch, t_batch)

UFuncTypeError: Cannot cast ufunc 'subtract' output from dtype('complex128') to dtype('float64') with casting rule 'same_kind'

該当のソースコード

Python3.8.5
1class Affine:
2    def __init__(self, W, b):
3        self.W = W
4        self.b = b
5        
6        self.x = None
7        self.original_x_shape = None
8        # 重み・バイアスパラメータの微分
9        self.dW = None
10        self.db = None
11
12    def forward(self, x):
13        # テンソル対応
14        self.original_x_shape = x.shape
15        x = x.reshape(x.shape[0], -1)
16        self.x = x
17
18        out = np.dot(x.real, self.W.real) + 1.j * np.dot(x.imag, self.W.imag) + self.b
19
20        return out
21
22    def backward(self, dout):
23        dx = np.dot(dout, self.W.T)
24        self.dW = np.dot(self.x.T, dout)
25        self.db = np.sum(dout, axis=0)
26        
27        dx = dx.reshape(*self.original_x_shape)  # 入力データの形状に戻す（テンソル対応）
28        return dx
29
30--------------------------------------------------------------------------------------
31class TwoLayerNet:
32
33    def __init__(self, input_size, hidden_size, output_size, weight_init_std = 0.01):
34        # 重みの初期化
35        self.params = {}
36        self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
37        self.params['b1'] = np.zeros(hidden_size)
38        self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size) 
39        self.params['b2'] = np.zeros(output_size)
40
41
42        # レイヤの生成
43        self.layers = OrderedDict()
44        self.layers['Affine1'] = Affine(self.params['W1'], self.params['b1'])
45        self.layers['Relu1'] = Relu()
46        self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2'])
47        self.lastLayer = SoftmaxWithLoss()
48        
49    def predict(self, x):
50        for layer in self.layers.values():
51            x = layer.forward(x)
52        
53        return x
54        
55    # x:入力データ, t:教師データ
56    def loss(self, x, t):
57        y = self.predict(x)
58        return self.lastLayer.forward(y, t)
59    
60    def accuracy(self, x, t):
61        y = self.predict(x)
62        y = np.argmax(y, axis=1)
63        if t.ndim != 1 : t = np.argmax(t, axis=1)
64        
65        accuracy = np.sum(y == t) / float(x.shape[0])
66        return accuracy
67        
68    # x:入力データ, t:教師データ
69    def numerical_gradient(self, x, t):
70        loss_W = lambda W: self.loss(x, t)
71        
72        grads = {}
73        grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
74        grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
75        grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
76        grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
77        
78        return grads
79        
80    def gradient(self, x, t):
81        # forward
82        self.loss(x, t)
83
84        # backward
85        dout = 1
86        dout = self.lastLayer.backward(dout)
87        
88        layers = list(self.layers.values())
89        layers.reverse()
90        for layer in layers:
91            dout = layer.backward(dout)
92
93        # 設定
94        grads = {}
95        grads['W1'], grads['b1'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
96        grads['W2'], grads['b2'] = self.layers['Affine2'].dW, self.layers['Affine2'].db
97
98        return grads
99--------------------------------------------------------------------------------------
100import sys, os
101sys.path.append(os.pardir)  # 親ディレクトリのファイルをインポートするための設定
102import numpy as np
103import matplotlib.pyplot as plt
104from dataset.mnist import load_mnist
105
106# データの読み込み
107(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)
108
109network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)
110
111iters_num = 10000  # 繰り返しの回数を適宜設定する
112train_size = x_train.shape[0]
113batch_size = 100
114learning_rate = 0.1
115
116train_loss_list = []
117train_acc_list = []
118test_acc_list = []
119
120iter_per_epoch = max(train_size / batch_size, 1)
121
122for i in range(iters_num):
123    batch_mask = np.random.choice(train_size, batch_size)
124    x_batch = x_train[batch_mask]
125    t_batch = t_train[batch_mask]
126    
127    # 勾配の計算
128    #grad = network.numerical_gradient(x_batch, t_batch)
129    grad = network.gradient(x_batch, t_batch)
130    
131    # パラメータの更新
132    for key in ('W1', 'b1', 'W2', 'b2'):
133        network.params[key] -= learning_rate * grad[key]
134    
135    loss = network.loss(x_batch, t_batch)
136    train_loss_list.append(loss)
137    
138    if i % iter_per_epoch == 0:
139        train_acc = network.accuracy(x_train, t_train)
140        test_acc = network.accuracy(x_test, t_test)
141        train_acc_list.append(train_acc)
142        test_acc_list.append(test_acc)
143        print("train acc, test acc | " + str(train_acc) + ", " + str(test_acc))
144