機械翻訳: Google 翻訳がほぼすべての言語を翻訳できる仕組み

[[345484]]

誰もが Google 翻訳をよく知っているはずですが、ほぼすべての既知の言語を私たちが選んだ言語に翻訳できる方法を疑問に思ったことはありませんか?この記事では、この謎を解き明かし、Long Short-Term Memory (LSTM) ネットワークを使用して言語翻訳プログラムを構築する方法を説明します。

この記事は2つの部分に分かれています。最初の部分では、ニューラル機械翻訳 (NMT) とエンコーダー/デコーダー構造について簡単に説明します。パート 2 では、Python を使用して言語翻訳プログラムを作成する詳細な手順を説明します。

[[345485]]

画像出典: Google

機械翻訳とは何ですか?

機械翻訳は、ある言語のソーステキストを別の言語のテキストに自動的に変換する方法を研究する計算言語学の分野です。機械翻訳の分野では、入力はすでに特定の言語の記号のシーケンスで構成されており、コンピューターはそれを別の言語の記号のシーケンスに変換する必要があります。

ニューラルネットワーク機械翻訳は、機械翻訳の分野で提案された提案です。人工ニューラルネットワークを使用して、特定の単語シーケンスの確率を予測し、多くの場合、文全体を単一のアンサンブルモデルでモデル化します。

ニューラルネットワークの力により、ニューラルネットワークマシン翻訳は翻訳分野で最も強力なアルゴリズムになりました。この最先端のアルゴリズムはディープラーニングの応用であり、翻訳された文章の大規模なデータセットを使用して、任意の言語ペア間で翻訳できるモデルをトレーニングします。

Google 言語翻訳

Seq2Seqアーキテクチャを理解する

名前が示すように、Seq2Seq は単語のシーケンス (1 つ以上の文) を入力として受け取り、単語の出力シーケンスを生成します。これは、リカレントニューラルネットワーク (RNN) を使用して実現されます。具体的には、特別なトークンと一緒に実行される 2 つの再帰型ニューラルネットワークが、前のシーケンスに基づいて次の状態のシーケンスを予測しようとします。

シンプルなエンコーダ・デコーダアーキテクチャ

主にエンコーダーとデコーダーの 2 つの部分で構成されているため、エンコーダーデコーダーネットワークと呼ばれることもあります。

エンコーダー: 複数のディープニューラルネットワークレイヤーを使用して、入力された単語を対応する隠しベクトルに変換します。各ベクトルは現在の単語とそのコンテキストを表します。

デコーダー: エンコーダーと同様です。エンコーダーによって生成された隠しベクトル、エンコーダー自身の隠し状態、および現在の単語を入力として受け取り、次の隠しベクトルを生成して、最終的に次の単語を予測します。

ニューラル機械翻訳の最終的な目標は、ある言語の入力文を受け取り、その文を別の言語に翻訳して出力することです。次の図は、中国語から英語への翻訳アルゴリズムを簡単に表示したものです。

「知識は力なり」を中国語に翻訳します。

どのように機能しますか?

最初のステップは、何らかの方法でテキストデータをデジタル形式に変換することです。機械翻訳でこれを実現するには、各単語をモデルに取り込むことができる One Hot Encoding ベクトルに変換する必要があります。ワンホットエンコードされたベクトルは、すべてのインデックスに 0 が含まれるベクトルです (特定の単語に対応する単一のインデックスにのみ 1 が含まれます)。

ワンホットエンコーディング

これらのベクトルは、入力言語の各一意の単語にインデックスを設定し、出力言語にも同様に設定することによって作成されます。それぞれの固有の単語に固有のインデックスを割り当てると、各言語の「語彙」と呼ばれるものが作成されます。理想的には、各言語の語彙には、その言語に固有の単語だけが含まれます。

上の図に示すように、各単語は長さ 9 (これは語彙のサイズです) のベクトルに変換され、1 を除くすべてのインデックスは 0 になります。

入力言語と出力言語の語彙を作成することにより、この技術をあらゆる言語のあらゆる文に適用することができ、コーパス内のすべての翻訳文を機械翻訳タスクに適した形式に完全に変換することができます。

それでは、エンコーダー/デコーダーアルゴリズムの背後にある魔法を体験してみましょう。最も基本的なレベルでは、モデルのエンコーダー部分は入力言語の文を受け取り、その文から思考ベクトルを作成します。この意味ベクトルには文の意味が格納され、それがデコーダーに渡されて文が出力言語に変換されます。

エンコーダー-デコーダー構造は英語の文章「私は学生です」をドイツ語に翻訳します。

エンコーダーの場合、入力文の各単語は、複数の連続した時間ステップで個別にモデルに入力されます。各タイムステップ (t) で、モデルはそのタイムステップでモデルに入力された単語の情報を使用して隠しベクトル (h) を更新します。

隠しベクトルは入力文の情報を格納するために使用されます。したがって、タイムステップ t=0 ではまだエンコーダに単語が入力されていないため、そのタイムステップでのエンコーダの隠し状態は空のベクトルで始まります。下の図では、青いボックスで隠れ状態を示しています。下付き文字 t=0 は時間ステップを表し、上付き文字 E はそれがエンコーダーの隠れ状態であることを示しています [D はデコーダーの隠れ状態を表すために使用されます]。

各タイムステップで、この隠しベクトルは、そのタイムステップの入力ワードから情報を取り込みながら、前のタイムステップから保存された情報を保持します。したがって、最後のタイムステップでは、入力文全体の意味が隠しベクトルに格納されます。最後のタイムステップの隠しベクトルは、前述のセマンティックベクトルであり、後でデコーダーに入力されます。

また、エンコーダーの最終的な隠しベクトルがセマンティックベクトルになり、t = 0 で上付き文字 D で再ラベル付けされることに注意してください。これは、エンコーダの最終的な隠しベクトルがデコーダの初期の隠しベクトルになるためです。このようにして、エンコードされた文の意味がデコーダーに渡され、デコーダーはそれを出力言語に変換します。ただし、エンコーダとは異なり、デコーダは可変長の翻訳を出力する必要があります。したがって、デコーダーは完全な文を出力するまで、各タイムステップで予測された単語を出力します。

翻訳を開始する前に、デコーダーの最初のタイムステップの入力として <SOS> タグを入力する必要があります。エンコーダーと同様に、デコーダーはタイムステップ t=1 での <SOS> 入力を使用して、隠し状態を更新します。ただし、デコーダーは次のタイムステップに進むだけでなく、追加の重みマトリックスを使用して出力語彙内のすべての単語の確率を作成します。このようにして、出力語彙の中で最も確率の高い単語が、予測された出力文の最初の単語になります。

デコーダーは可変長の予測文を出力する必要があり、予測文の次の単語が <EOS> タグになるまでこの方法で単語の予測を続けます。ラベル予測が完了すると、デコード処理が完了し、入力文の完全な予測翻訳が表示されます。

Keras と Python によるニューラル機械翻訳

エンコーダーとデコーダーのアーキテクチャを理解したので、Keras と Python を使用して英語の文章をフランス語に翻訳するモデルを作成します。最初のステップでは、必要なライブラリをインポートし、コードで使用するさまざまなパラメータの値を設定します。

 #ライブラリのインポート
os、sysをインポートする
         keras.modelsからimportModel
         keras.layers から入力、LSTM、GRU、Dense、Embedding をインポートします
         keras.preprocessing.text から Tokenizer をインポートします。keras.preprocessing.sequence からpad_sequencesをインポートします。
         keras.utilsからto_categoricalをインポートする
numpyをnpとしてインポートする
pandasをpdとしてインポートする
輸入ピクルス
         matplotlib.pyplot を plt としてインポートします。
             #さまざまなパラメータの値: BATCH_SIZE= 64  
         エポック= 20  
         LSTM_NODES = 256  
         文数 = 20000  
         最大文の長さ = 50  
         最大単語数 = 20000  
         埋め込みサイズ = 200

データセット

英語の文章とそのフランス語の翻訳を含むデータセットが必要です。fra-eng.zip ファイルをダウンロードして解凍します。テキストファイルの各行には、タブで区切られた英語の文とそのフランス語の翻訳が含まれています。各行を入力テキストとターゲットテキストに分割し続けます。

入力文 = []
                出力文 = [] 出力文入力 = [] カウント = 0  
行inopen( './drive/MyDrive/fra.txt' 、 encoding= "utf-8" ):
                    カウント += 1  
カウント > NUM_SENTENCESの場合:
壊す 
 '\t'が行内にない場合:
続く 
                    input_sentence = line.rstrip().split( '\t' )[ 0 ]
                    出力 = line.rstrip().split( '\t' )[ 1 ]
                 出力文 = 出力 + ' <eos>'  
                    output_sentence_input = '<sos>' + 出力
                 input_sentences.append(入力文)
                    出力文を追加します。(出力文)
                    出力文入力.append(出力文入力)
             print( "サンプル入力の数:" , len(input_sentences))
                print( "サンプル出力の数:" , len(output_sentences))
                print( "サンプル出力入力の数: " , len(output_sentences_inputs))

出力：
サンプル入力数: 20000  
サンプル出力数: 20000  
サンプル出力入力数: 20000

上記のスクリプトでは、input_sentences[]、output_sentences[]、およびoutput_sentences_inputs[]の3つのリストが作成されます。次に、for ループで、fra.txt ファイルの各行を 1 行ずつ読み取ります。各行は、タブ文字が発生する位置で 2 つの部分文字列に分割されます。左側の部分文字列（英語の文）がinput_sentences[]リストに挿入されます。タブ文字の右側の部分文字列は、対応するフランス語の翻訳です。

ここでは、翻訳された文の先頭に、文の終わりを示す <eos> タグが追加されます。同様に、「文の始まり」を意味する <sos> タグは、翻訳された文の先頭に接続されます。または、リストからランダムに文を出力します。

 print( "英語の文章: " , input_sentences[ 180 ])
 print( "フランス語翻訳: " , output_sentences[ 180 ])
出力:英語の文: Join us.フランス語の翻訳: Joignez-vous à nous.<eos>

マーキングと充填

次のステップは、ソース文と翻訳文をトークン化し、特定の長さより長いまたは短い文を埋めることです。入力の場合、この長さは入力文の最大長になります。出力の場合、出力文の最大長でもあります。それをする前に、文の長さを想像してみましょう。すべての文の長さを、それぞれ英語とフランス語の 2 つの別々のリストで取得します。

 eng_len = []
       fren_len = [] # リストに文の長さを入力しますfor i ininput_sentences:
            eng_len.append(len(i.split()))
 i inoutput_sentencesの場合:
            fren_len.append(len(i.split()))
             length_df = pd.DataFrame({ '英語' :eng_len, 'フランス語' :fren_len})
             length_df.hist(ビン = 20 )
       plt.show()

上記のヒストグラムは、フランス語の文の最大長が 12 で、英語の文の最大長が 6 であることを示しています。

次に、Keras の Tokenizer() クラスを使用してテキストデータをベクトル化します。したがって、文は整数のシーケンスになります。次に、これらのシーケンスの長さが同じになるようにゼロを埋め込みます。

トークナイザークラスの word_index 属性は、キーが単語を表し、値が対応する整数を表す単語インデックスの辞書を返します。最後に、上記のスクリプトは、辞書内の一意の単語の数と、入力された最長の英語の文の長さを出力します。

 #入力文をトークン化する(入力言語)
                input_tokenizer = Tokenizer(num_words=MAX_NUM_WORDS) input_tokenizer.fit_on_texts(input_sentences) input_integer_seq = input_tokenizer.texts_to_sequences(input_sentences) print(input_integer_seq)
             word2idx_inputs = input_tokenizer.word_index print( '入力内のユニークワードの合計数: %s' %len(word2idx_inputs))
             max_input_len = max(len(sen)、ただし、 sen は input_integer_seq に含まれる)
                print( "入力中の最長文の長さ: %g" % max_input_len)

出力：
入力内の固有単語の総数: 3501  
入力された最長文の長さ: 6

同様に、出力ステートメントも同じ方法でマークできます。

 #出力文をトークン化する（出力言語）
 output_tokenizer =トークナイザー(num_words=MAX_NUM_WORDS, フィルター= '' )
 output_tokenizer.fit_on_texts(出力センテンス+出力センテンス入力) output_integer_seq = output_tokenizer.texts_to_sequences(出力センテンス) output_input_integer_seq = output_tokenizer.texts_to_sequences(出力センテンス_入力) print(output_input_integer_seq)
           word2idx_outputs=output_tokenizer.word_index print( '出力内のユニークワードの合計数: %s' %len(word2idx_outputs))
           num_words_output = len(word2idx_outputs) + 1  
 max_out_len = max(len(sen)、sen inoutput_integer_seqの場合)
 print( "出力内の最長文の長さ: %g" % max_out_len)

出力：
出力内のユニーク単語の総数: 9511  
出力内の最長文の長さ: 12

これで、上のヒストグラムを使用して、両方の言語の最長文の長さを確認できます。また、英語の文章は一般的にフランス語の翻訳文よりも短く、平均して単語数も少ないという結論も出せます。

次に入力内容を記入する必要があります。入力と出力にパディングを行う理由は、テキストの文の長さは固定されていないが、LSTM ネットワークでは入力例文の長さが同じであると想定しているためです。したがって、文を固定長のベクトルに変換する必要があります。この目的のために、パディングが 1 つの方法となります。

 #エンコーダ入力のパディング
 エンコーダー入力シーケンス = pad_sequences(input_integer_seq, maxlen = max_input_len) print( "エンコーダー入力シーケンス.shape: " , エンコーダー入力シーケンス.shape)
            #デコーダー入力のパディングdecoder_input_sequences = pad_sequences(output_input_integer_seq, maxlen = max_out_len, padding = 'post' )
 print( "decoder_input_sequences.shape:" ,decoder_input_sequences.shape)
            #デコーダー出力のパディングdecoder_output_sequences = pad_sequences(output_integer_seq, maxlen = max_out_len, padding = 'post' )
 print( "decoder_output_sequences.shape:" ,decoder_output_sequences.shape)

エンコーダ入力シーケンスの形状: ( 20000 , 6 )
デコーダー入力シーケンスの形状: ( 20000 , 12 )
デコーダー出力シーケンスの形状: ( 20000 , 12 )

入力には 20,000 文 (英語) があり、各入力文の長さは 6 なので、入力は (20,000, 6) の形式になります。同様に、出力には 20,000 文（フランス語）があり、各出力文の長さは 12 なので、出力は (20,000, 12) の形式になり、翻訳された言語でも同様になります。

インデックス 180 の元の文が join us だったことを覚えているかもしれません。トークナイザーは文を join と us という単語に分割し、それらを整数に変換してから、入力リストのインデックス 180 の文に対応する整数シーケンスの先頭に 4 つのゼロを追加して事前にパディングします。

 print( "encoder_input_sequences[180]:" ,encoder_input_sequences[ 180 ])出力:
エンコーダ入力シーケンス[ 180 ]: [ 0     0    0     0   464    59 ]

join と us の整数値がそれぞれ 464 と 59 であることを確認するには、次に示すように単語を word2index_inputs 辞書に渡します。

 prnt(word2idx_inputs[ "結合" ])
 print(word2idx_inputs[ "us" ])出力:
 464  
 59

さらに注目すべき点は、デコーダーがポストパディング方式、つまり文末にゼロを追加する方式を採用することです。一方、エンコーダーでは、先頭の位置にゼロが埋め込まれます。このアプローチの背後にある理由は、エンコーダーの出力は文末に現れる単語に基づいているため、元の単語は文末に保持され、先頭にゼロが埋め込まれるという点です。デコーダーは文を最初から処理するため、デコーダーの入力と出力に対して後パディングが実行されます。

単語埋め込み

[[345488]]

画像ソース: unsplash

まず、単語を対応するデジタルベクトル表現に変換し、そのベクトルをディープラーニングモデルに入力する必要があります。単語を数字に変換することもできました。では、整数/数値表現と単語埋め込みベクトルの違いは何でしょうか?

単一の整数表現と単語埋め込みベクトルには、主に 2 つの違いがあります。整数表現では、単語は 1 つの整数のみで表現されます。一方、ベクトル表現では、単語は 50、100、200 など任意の次元数で表現できます。したがって、単語埋め込みベクトルは単語に関するより多くの情報を取得できます。第二に、単一の整数表現では、異なる単語間の関係を捉えることができません。単語埋め込みベクトルはこれを可能にします。

英語の文章（つまり入力）の場合、GloVe 単語埋め込みモデルを使用します。フランス語の翻訳出力には、カスタム単語埋め込みモデルを使用します。 GloVe 単語埋め込みモデルをダウンロードするには、ここをクリックしてください。

まず、入力コンテンツの単語埋め込みベクトルを作成します。その前に、GloVe ワードベクトルをメモリにロードする必要があります。次に、単語をキーとして、対応するベクトルを値として持つ辞書を作成します。

 numpyから配列をインポート
 NumPyからasarrayをインポート
 numpyからゼロをインポート
            埋め込み辞書 = dict() glove_file = open(r './drive/My Drive/glove.twitter.27B.200d.txt' 、エンコーディング = "utf8" )
 glove_file内の行:
     rec = line.split() 単語 = rec[ 0 ]
    ベクトル次元 = asarray(rec[ 1 :], dtype= 'float32' )
    埋め込み辞書[単語] = ベクトル寸法 glove_file.close()

入力には 3501 個の一意の単語が含まれていることを思い出してください。行数が単語の整数値を表し、列数が単語の次元数に対応する行列を作成します。この行列には、入力文内の単語の単語埋め込みベクトルが含まれます。

 num_words = min(MAX_NUM_WORDS, len(word2idx_inputs) + 1 )
                     埋め込みマトリックス = zeros((num_words, EMBEDDING_SIZE))、単語、インデックス inword2idx_inputs.items(): 埋め込みベクター =embeddings_dictionary.get(word) 、埋め込みベクターがNoneでない場合:埋め込みマトリックス[インデックス] =embedding_vector

モデルの作成

最初のステップは、ニューラルネットワークの埋め込みレイヤーを作成することです。埋め込み層は、ネットワークの最初の隠し層であると考えられます。 3 つのパラメータを指定する必要があります。

input_dim: テキストデータ内の語彙のサイズを表します。たとえば、データが 0 から 10 までの値を持つ整数としてエンコードされている場合、語彙のサイズは 11 語になります。

output_dim: 単語が埋め込まれるベクトル空間のサイズを表します。このレイヤー内の各単語の出力ベクトルのサイズを決定します。たとえば、32 や 100、あるいはそれ以上の数値にすることもできます。これについて疑問がある場合は、異なる値でテストすることができます。

input_length: Keras モデルの入力層に定義されている入力シーケンスの長さを表します。たとえば、すべての入力ドキュメントが 1000 語で構成されている場合、この値も 1000 になります。

埋め込みレイヤー = 埋め込み(単語数、埋め込みサイズ、重み=[埋め込みマトリックス]、入力長さ=最大入力長さ)

次に必要なのは出力を定義することですが、出力は単語のシーケンスになることは誰もが知っています。出力内の一意の単語の総数は 9511 であることを思い出してください。したがって、出力内の各単語は、これらの 9511 個の単語のいずれかになります。出力文の長さは12です。すべての入力文には対応する出力文が必要です。したがって、最終的な出力形式は次のようになります: (入力量、出力文の長さ、出力される単語数)

 #出力の形状
デコーダーターゲットワンホット = np.zeros((len(入力文), max_out_len,num_words_output),
 dtype = 'float32'  
 )decoder_targets_one_hot.shapeシェイプ: ( 20000 , 12 , 9512 )

予測を行うには、モデルの最後の層が密な層になります。密な層ではソフトマックス活性化関数を使用するため、出力はワンホットエンコードされたベクトルの形式である必要があります。ワンホットエンコードされた出力を作成するには、次の手順として、単語の整数表現に対応する列番号に 1 を割り当てます。

 enumerate(decoder_output_sequences) 内の i、dについて:
 tの場合、enumerate(d)内の単語:
        デコーダーターゲットワンホット[i, t, 単語] = 1

次のステップは、エンコーダーネットワークとデコーダーネットワークを定義することです。エンコーダーは英語の文章を入力し、LSTM ネットワークの隠れ状態とセル状態を出力します。

エンコーダ入力 = 入力(shape=(max_input_len,))
                              x = 埋め込みレイヤー(エンコーダー入力) エンコーダー = LSTM(LSTM_NODES, return_state=True)
             エンコーダ出力、h、c = エンコーダ(x) エンコーダ状態 = [h、c]

次のステップはデコーダーを定義することです。デコーダーには、エンコーダーの隠し状態とセル状態という 2 つの入力があります。セル状態は、基本的にトークンが先頭に追加された出力文です。

デコーダー入力 = 入力(shape=(max_out_len,))
デコーダー埋め込み = 埋め込み(num_words_output、LSTM_NODES) デコーダー入力_x = デコーダー埋め込み(デコーダー入力) デコーダーlstm = LSTM(LSTM_NODES、return_sequences=True、return_state=True)
 decoder_outputs, _, _ =decoder_lstm(decoder_inputs_x,initial_state=encoder_states) #最後に、デコーダー LSTM からの出力が密なレイヤーに渡され、デコーダー出力が予測されます。
デコーダー密度 = 密度(num_words_output、アクティベーション = 'softmax' )
デコーダー出力 = デコーダー密度(デコーダー出力)

モデルのトレーニング

オプティマイザーとクロスエントロピー損失を定義してモデルをコンパイルします。

 ＃コンパイル
        モデル = モデル([エンコーダ入力,デコーダ入力],デコーダ出力)
        モデル.コンパイル(
           オプティマイザー = 'rmsprop' 、
           損失 = 'カテゴリクロスエントロピー' 、
           メトリック=[ '精度' ]
        ）
        モデル.要約()

結果は予想通りでした。エンコーダー lstm_2 は埋め込み層からの入力を受け入れ、デコーダー lstm_3 はエンコーダーと埋め込み層の内部状態を使用します。このモデルには合計で約 650 万のパラメータがあります。モデルをトレーニングするときは、コンピューティングリソースの浪費と過剰適合を避けるために、EarlyStopping() パラメータを指定することをお勧めします。

 es =EarlyStopping(モニター= 'val_loss' 、モード= 'min' 、詳細= 1 )
             history = model.fit([encoder_input_sequences,decoder_input_sequences],decoder_targets_one_hot,batch_size=BATCH_SIZE,epochs= 20 ,
                                      コールバック=[es]、validation_split= 0.1 、
                                  ）

モデルの重みを保存します。

モデルを保存します( 'seq2seq_eng-fra.h5' )

トレーニングデータとテストデータの精度曲線をプロットします。

 ＃正確さ
plt.title( 'モデルの精度' )
 plt.plot(history.history[ '精度' ])
 plt.plot(history.history[ 'val_accuracy' ])
 plt.ylabel( '精度' )
 plt.xlabel( 'エポック' )
 plt.legend([ 'train' , 'test' ], loc= '左上' )
 plt.show()

ご覧のとおり、モデルのトレーニング精度は約 87%、テスト精度は約 77% を達成しており、これはモデルが過剰適合していることを示しています。 20,000 件のレコードのみでトレーニングしたので、レコードをさらに追加したり、ドロップアウトレイヤーを追加してオーバーフィッティングを減らすこともできます。

機械翻訳モデルのテスト

モデルの重みをロードし、モデルをテストします。

エンコーダモデル = モデル(エンコーダ入力、エンコーダ状態)
 model.compile(オプティマイザー= 'rmsprop' 、損失= 'categorical_crossentropy' )
モデル.load_weights( 'seq2seq_eng-fra.h5' )

重みを設定したら、いくつかの文を翻訳して機械翻訳モデルをテストします。推論モードの動作原理はトレーニングプロセスとは少し異なります。プロセスは次の 4 つのステップに分けられます。

入力シーケンスをエンコードし、その内部状態を返します。

シーケンス開始文字のみを入力として使用し、エンコーダーの内部状態をデコーダーの初期状態として使用してデコーダーを実行します。

デコーダーによって予測された文字（トークンを検索した後）をデコードされたシーケンスに追加します。

以前に予測された文字トークンを入力として受け取り、プロセスを繰り返して内部状態を更新します。

入力シーケンスをエンコードするにはエンコーダーのみが必要なので、エンコーダーとデコーダーを 2 つの別々のモデルに分離します。

デコーダー状態入力h = 入力(shape=(LSTM_NODES,))
                           デコーダー状態入力c = 入力(形状 = (LSTM_NODES,)) デコーダー状態入力 = [デコーダー状態入力h, デコーダー状態入力c] デコーダー状態入力シングル = 入力(形状 = ( 1 ,))
                           デコーダー入力シングル x = デコーダー埋め込み (デコーダー入力シングル) デコーダー出力、h、c = デコーダー lstm (デコーダー入力シングル x、初期状態 = デコーダー状態_inputs) デコーダー状態 = [h、c] デコーダー出力 = デコーダー_dense (デコーダー出力) デコーダーモデル = モデル ( [デコーダー入力シングル] + デコーダー状態_inputs、[デコーダー出力] + デコーダー状態

出力はフランス語の単語のシーケンスにしたいです。したがって、整数を単語に戻す必要があります。入力と出力の両方に対して、キーが整数で対応する値が単語である新しい辞書を作成します。

 idx2word_input = {v: kの場合k 、v の場合 inword2idx_inputs.items()}
 idx2word_target = {v:kの場合k 、v の場合 inword2idx_outputs.items()}

このメソッドは、入力パディングされたシーケンス (整数形式) を含む英語の文を受け入れ、フランス語の翻訳を返します。

 def translate_sentence(input_seq):
                                   states_value = エンコーダーモデル.predict(input_seq) ターゲットシーケンス = np.zeros(( 1 , 1 ))
                                   target_seq[ 0 , 0 ] =word2idx_outputs[ '<sos>' ]
                                   eos = word2idx_outputs[ '<eos>' ]
                                   output_sentence = [] _ inrange(max_out_len):
                                       出力トークン、h、c = デコーダーモデル.predict([target_seq] + states_value) idx = np.argmax(出力トークン[ 0 、 0 、 :])
 eos == idxの場合:
壊す 
                     単語 = ''  
 idx > 0の場合:
                                           word = idx2word_target[idx] output_sentence.append(word) target_seq[ 0 , 0 ] = idx
                                       states_value = [h, c] ' ' .join(output_sentence)を返します

予測する

モデルのパフォーマンスをテストするには、input_sentences リストから文をランダムに選択し、その文に対応するパディングされたシーケンスを取得して、translate_sentence() メソッドに渡します。このメソッドは翻訳された文を返します。

 i = np.random.choice(len(入力文))
                                       input_seq = エンコーダ入力シーケンス[i:i+ 1 ]
                                       translation = translate_sentence(input_seq) print( '入力言語: ' , input_sentences[i])
                                       print( '実際の翻訳:' , output_sentences[i])
                                       print( 'フランス語翻訳:' ,翻訳)

結果：

大成功です！ニューラルネットワーク翻訳モデルは、非常に多くの文章をフランス語に翻訳することに成功しました。 Google翻訳で確認することもできます。もちろん、すべての文章を正しく翻訳できるわけではありません。精度をさらに向上させるには、「アテンションメカニズム」を検索し、それをエンコーダー/デコーダー構造に埋め込むことができます。

[[345489]]

画像ソース: unsplash

manythings.org からドイツ語、ヒンディー語、スペイン語、ロシア語、イタリア語などの言語のデータセットをダウンロードし、言語翻訳用のニューラルネットワーク翻訳モデルを構築できます。

ニューラルマシントランスレーション (NMT) は、非常に複雑なアーキテクチャを伴う、自然言語処理の分野におけるかなり高度なアプリケーションです。この記事では、Seq2Seq 学習のための長短期記憶層と組み合わせたエンコーダー/デコーダーモデルの機能について説明します。エンコーダーは入力文をエンコードする長短期メモリであり、デコーダーは入力をデコードして対応する出力を生成するために使用されます。

<<: 人工知能、遺伝子編集、ノーベル賞の画期的な進歩により、80歳でも40歳に見えるようになる

>>: 100日学習プラン | データサイエンスの詳細ガイド