質問編集履歴

解決

2020/01/02 11:19

投稿

hosihosieruhu

スコア8

test CHANGED Viewed

File without changes

test CHANGED Viewed

@@ -1,741 +1 @@
 ChainerでRNNを使って自動文章生成したいのですが、TypeError: Can't broadcastという調べてもよくわからないエラーがでます。
-ソースは「Chainerで作るコンテンツ自動生成AIプログラミング入門」という本のコピペです。
-環境はgoogle colabです。
-cudaとcupy、chainerのバージョンも合ってます
-プログラムは2つです
-以下が用意したテキストファイルをRNNで学習させるプログラムchapt07-2.pyです。
-ちなみにテキストファイルは２万行の俳句です。
-```
-import chainer
-import chainer.functions as F
-import chainer.links as L
-from chainer import training, datasets, iterators, optimizers
-from chainer.training import extensions
-import numpy as np
-import codecs
-batch_size = 10                # バッチサイズ10
-uses_device = 0                # GPU#0を使用
-# GPU使用時とCPU使用時でデータ形式が変わる
-if uses_device >= 0:
-    import cupy as cp
-else:
-    cp = np
-# RNNの定義をするクラス
-class Parses_Genarate_RNN(chainer.Chain):
-    def __init__(self, n_words, nodes):
-        super(Parses_Genarate_RNN, self).__init__()
-        with self.init_scope():
-            self.embed = L.EmbedID(n_words, n_words)
-            self.l1 = L.LSTM(n_words, nodes)
-            self.l2 = L.LSTM(nodes, nodes)
-            self.l3 = L.Linear(nodes, n_words)
-    def reset_state(self):
-        self.l1.reset_state()
-        self.l2.reset_state()
-    def __call__(self, x):
-        h0 = self.embed(x)
-        h1 = self.l1(h0)
-        h2 = self.l2(h1)
-        y = self.l3(h2)
-        return y
-# カスタムUpdaterのクラス
-class RNNUpdater(training.StandardUpdater):
-    def __init__(self, train_iter, optimizer, device):
-        super(RNNUpdater, self).__init__(
-            train_iter,
-            optimizer,
-            device=device
-        )
-    def update_core(self):
-        # 累積してゆく損失
-        loss = 0
-        # IteratorとOptimizerを取得
-        train_iter = self.get_iterator('main')
-        optimizer = self.get_optimizer('main')
-        # ニューラルネットワークを取得
-        model = optimizer.target
-        # 文を一バッチ取得
-        x = train_iter.__next__()
-        # RNNのステータスをリセットする
-        model.reset_state()
-        # 分の長さだけ繰り返しRNNに学習
-        for i in range(len(x[0])-1):
-            # バッチ処理用の配列に
-            batch = cp.array([s[i] for s in x], dtype=cp.int32)
-            # 正解データ（次の文字）の配列
-            t = cp.array([s[i+1] for s in x], dtype=cp.int32)
-            # 全部が終端文字ならそれ以上学習する必要は無い
-            if cp.min(batch) == 1 and cp.max(batch) == 1:
-                break
-            # 一つRNNを実行
-            y = model(batch)
-            # 結果との比較
-            loss += F.softmax_cross_entropy(y, t)
-        # 重みデータを一旦リセットする
-        optimizer.target.cleargrads()
-        # 誤差関数から逆伝播する
-        loss.backward()
-        # 新しい重みデータでアップデートする
-        optimizer.update()
-# ファイルを読み込む
-s = codecs.open('all-sentences-parses.txt', 'r', 'utf8')
-# 全ての文
-sentence = []
-# 1行ずつ処理する
-line = s.readline()
-while line:
-    # 一つの文
-    one = [0] # 開始文字だけ
-    # 行の中の単語を数字のリストにして追加
-    one.extend(list(map(int,line.split(','))))
-    # 行が終わったところで終端文字を入れる
-    one.append(1)
-    # 新しい文を追加
-    sentence.append(one)
-    line = s.readline()
-s.close()
-# 単語の種類
-n_word = max([max(l) for l in sentence]) + 1
-# 最長の文の長さ
-l_max = max([len(l) for l in sentence])
-# バッチ処理の都合で全て同じ長さに揃える必要がある
-for i in range(len(sentence)):
-    # 足りない長さは終端文字で埋める
-    sentence[i].extend([1]*(l_max-len(sentence[i])))
-# ニューラルネットワークの作成
-model = Parses_Genarate_RNN(n_word, 100)
-if uses_device >= 0:
-    # GPUを使う
-    chainer.cuda.get_device_from_id(0).use()
-    chainer.cuda.check_cuda_available()
-    # GPU用データ形式に変換
-    model.to_gpu()
-# 誤差逆伝播法アルゴリズムを選択
-optimizer = optimizers.Adam()
-optimizer.setup(model)
-# Iteratorを作成
-train_iter = iterators.SerialIterator(sentence, batch_size, shuffle=False)
-# デバイスを選択してTrainerを作成する
-updater = RNNUpdater(train_iter, optimizer, device=uses_device)
-trainer = training.Trainer(updater, (100, 'epoch'), out="result")
-# 学習の進展を表示するようにする
-trainer.extend(extensions.ProgressBar(update_interval=1))
-# 機械学習を実行する
-trainer.run()
-# 学習結果を保存する
-chainer.serializers.save_hdf5( 'chapt07.hdf5', model )
-```
-以下が先ほど作成した学習結果を元に文章自動生成するプログラムchapt07-4.pyです。
-word2vecのモデルを使用ますが、これが壊れているという事は考えにくいです
-```
-import torch
-import torchvision
-import torchvision.transforms as transforms
-from torch import nn, optim
-import torch.nn.functional as F
-from torch.utils.data import Dataset, DataLoader, TensorDataset
-import numpy as np
-import sys
-import codecs
-from gensim.models import word2vec
-trainset = torchvision.datasets.MNIST(root='./data',
-                                        train=True,
-                                        download=True,
-                                        transform=transforms.ToTensor())
-trainloader = torch.utils.data.DataLoader(trainset,
-                                            batch_size=batch_size,
-                                            shuffle=True)
-testset = torchvision.datasets.MNIST(root='./data',
-                                        train=False,
-                                        download=True,
-                                        transform=transforms.ToTensor())
-testloader = torch.utils.data.DataLoader(testset,
-                                            batch_size=batch_size,
-                                            shuffle=False)
-# GPU使用時とCPU使用時でデータ形式が変わる
-if uses_device >= 0:
-    import cupy as cp
-    import chainer.cuda
-else:
-    cp = np
-sys.stdout = codecs.getwriter('utf_8')(sys.stdout)
-# RNNの定義をするクラス
-class Parses_Genarate_RNN(nn.Module):
-    def __init__(self, n_words, nodes):
-        super(Parses_Genarate_RNN, self).__init__()
-        with self.init_scope():
-            self.embed = L.EmbedID(n_words, n_words)
-            self.l1 = L.LSTM(n_words, nodes)
-            self.l2 = L.LSTM(nodes, nodes)
-            self.l3 = L.Linear(nodes, n_words)
-    def reset_state(self):
-        self.l1.reset_state()
-        self.l2.reset_state()
-    def __call__(self, x):
-        h0 = self.embed(x)
-        h1 = self.l1(h0)
-        h2 = self.l2(h1)
-        y = self.l3(h2)
-        return y
-# ファイルを読み込む
-w = codecs.open('all-words-parses.txt', 'r', 'utf8')
-# 単語の一覧
-words_parse = {}
-# 1行ずつ処理する
-line = w.readline()
-while line:
-    # 行の中の単語をリストする
-    l = line.split(',')
-    if len(l) == 2:
-        r = int(l[0].strip())
-        if r in words_parse:
-            words_parse[r].append(l[1].strip())
-        else:
-            words_parse[r] = [l[1].strip()]
-    line = w.readline()
-w.close()
-# ニューラルネットワークの作成
-model = Parses_Genarate_RNN(max(words_parse.keys())+1, 20)
-# 学習結果を読み込む
-chainer.serializers.load_hdf5( 'chapt07.hdf5', model )
-if uses_device >= 0:
-    # GPUを使う
-    chainer.cuda.get_device_from_id(0).use()
-    chainer.cuda.check_cuda_available()
-    # GPU用データ形式に変換
-    model.to_gpu()
-# 木探索で生成する最大の深さ
-words_max = 50
-# RNNの実行結果から検索する単語の数
-beam_w = 3
-# 生成した文のリスト
-parses = []
-# 木探索のスタック
-model_history = [model]
-# 現在生成中の文
-cur_parses = [0]        # 開始文字
-# 現在生成中の文のスコア
-cur_score = []
-# 最大のスコア
-max_score = 0
-# 再帰関数の木探索
-def Tree_Traverse():
-    global max_score
-    # 現在の品詞を取得する
-    cur_parse = cur_parses[-1]
-    # 文のスコア
-    score = np.prod(cur_score)
-    # 現在の文の長さ
-    deep = len(cur_parses)
-    # 枝刈り - 単語数が5以上で最大スコアの6割以下なら、終わる
-    if max_score > 0 and deep > 5 and max_score * 0.6 > score:
-        return
-    # 終了文字か、最大の文の長さ以上なら、品詞を追加して終わる
-    if cur_parse == 1 or deep > words_max:
-        # 文のデータをコピー
-        data = np.array(cur_parses)
-        # 文を追加
-        parses.append((score, data))
-        # 最大スコアを更新
-        if max_score < score:
-            max_score = score
-        return
-    # 現在のニューラルネットワークのステータスをコピーする
-    cur_model = model_history[-1].copy()
-    # 入力値を作る
-    x = cp.array([cur_parse], dtype=cp.int32)
-    # ニューラルネットワークに入力する
-    y = cur_model(x)
-    # 実行結果を正規化する
-    z = F.softmax(y)
-    # 結果のデータを取得
-    result = z.data[0]
-    if uses_device >= 0:
-        result = chainer.cuda.to_cpu(result)
-    # 結果を確立順に並べ替える
-    p = np.argsort(result)[::-1]
-    # 現在のニューラルネットワークのステータスを保存する
-    model_history.append(cur_model)
-    # 結果から上位のものを次の枝に回す
-    for i in range(beam_w):
-        # 現在生成中の文に一文字追加する
-        cur_parses.append(p[i])
-        # 現在生成中の文のスコアに一つ追加する
-        cur_score.append(result[p[i]])
-        # 再帰呼び出し
-        Tree_Traverse()
-        # 現在生成中の文を一つ戻す
-        cur_parses.pop()
-        # 現在生成中の文のスコアを一つ戻す
-        cur_score.pop()
-    # ニューラルネットワークのステータスを一つ戻す
-    model_history.pop()
-# 木検索して文章を生成する
-Tree_Traverse()
-# Word2Vecのモデルを読み込む
-word_vec = word2vec.Word2Vec.load('word2vec.gensim.model')
-# 文章のターゲット
-target_str = ['元日']
-#target_str = ['神']
-#target_str = ['キリスト']
-#target_str = ['父','子','聖霊']
-#target_str = ['不思議','の','国','の','アリス']
-#target_str = ['三月','うさぎ','の','お茶','会']
-#target_str = ['女王']
-# 指定した品詞の単語を文章がターゲットに近づくように返す
-def similarity_word( parse, history ):
-    scores = []
-    # 品詞から候補をリスト
-    for i in range(len(words_parse[parse])):
-        w = words_parse[parse][i]
-        if w in word_vec:
-            # 候補のベクトルを履歴ベクトルに足す
-            t = history[:]
-            t.append(w)
-            # ターゲットとの距離を計算
-            sim = word_vec.n_similarity(target_str, t)
-            scores.append((sim, w))
-    # 結果をスコア順に並べ替える
-    result = sorted(scores, key=lambda x: x[0])[::-1]
-    return result[0]
-# スコアの高いものから順に表示する
-result_set = sorted(parses, key=lambda x: x[0])[::-1]
-# 10個または全部の少ない方の数だけ表示
-for i in range(min([10,len(result_set)])):
-    # 結果を取得
-    s, l = result_set[i]
-    # これまで登場した単語
-    history = []
-    # 開始文字と終端文字を除いてループ
-    for j in range(1,len(l)-1):
-        score, cur_word = similarity_word(l[j], history)
-        history.append(cur_word)
-        sys.stdout.buffer.write(cur_word.encode('utf-8'))
-    sys.stdout.buffer.write("\n".encode('utf-8'))
-    sys.stdout.buffer.flush()
-```