input
stringlengths 0
542
| output
stringlengths 21
10.3k
| task
stringclasses 2
values | index
int64 0
5.16k
| liscence
stringclasses 1
value | source
stringclasses 5
values | instruction
stringlengths 24
3.45k
|
|---|---|---|---|---|---|---|
text = 'stressed'
print(text[::-1]) | code_generation | 555 | MIT | nlp_100_knocks | pythonを用いて、文字列”stressed”の文字を逆に（末尾から先頭に向かって）並べた文字列を表示しなさい。 |
|
text = 'パタトクカシーー'
print(text[1::2]) | code_generation | 556 | MIT | nlp_100_knocks | pythonを用いて、「パタトクカシーー」という文字列の1,3,5,7文字目を取り出して連結した文字列を表示しなさい。 |
|
text0 = 'パトカー'
text1 = 'タクシー'
ans = ''
for i in range(len(text0)):
ans += text0[i]
ans += text1[i]
print(ans) | code_generation | 557 | MIT | nlp_100_knocks | pythonを用いて、「パトカー」＋「タクシー」の文字を先頭から交互に連結して文字列「パタトクカシーー」を表示しなさい。 |
|
raw_text = 'Now I need a drink, alcoholic of course, after the heavy lectures involving quantum mechanics.'
text = raw_text.replace('.', '').replace(',', '')
ans = [len(w) for w in text.split()]
print(ans) | code_generation | 558 | MIT | nlp_100_knocks | pythonを用いて、“Now I need a drink, alcoholic of course, after the heavy lectures involving quantum mechanics.”という文を単語に分解し，各単語の（アルファベットの）文字数を先頭から出現順に並べたリストを作成せよ。 |
|
def extract_chars(i, word):
if i in [1, 5, 6, 7, 8, 9, 15, 16, 19]:
return (word[0], i)
else:
return (word[:2], i)
raw_text = 'Hi He Lied Because Boron Could Not Oxidize Fluorine. New Nations Might Also Sign Peace Security Clause. Arthur King Can.'
text = raw_text.replace('.', '').replace(',', '')
ans = [extract_chars(i, w) for i, w in enumerate(text.split(), 1)]
print(dict(ans)) | code_generation | 559 | MIT | nlp_100_knocks | pythonを用いて、“Hi He Lied Because Boron Could Not Oxidize Fluorine. New Nations Might Also Sign Peace Security Clause. Arthur King Can.”という文を単語に分解し，1, 5, 6, 7, 8, 9, 15, 16, 19番目の単語は先頭の1文字，それ以外の単語は先頭の2文字を取り出し，取り出した文字列から単語の位置（先頭から何番目の単語か）への連想配列（辞書型もしくはマップ型）を作成せよ。 |
|
def n_gram(target, n):
return [target[idx:idx + n] for idx in range(len(target) - n + 1)]
text = 'I am an NLPer'
for i in range(1, 4):
print(n_gram(text, i))
print(n_gram(text.split(' '), i)) | code_generation | 560 | MIT | nlp_100_knocks | pythonを用いて、与えられたシーケンス（文字列やリストなど）からn-gramを作る関数を作成せよ．この関数を用い，”I am an NLPer”という文から単語bi-gram，文字bi-gramを表示しなさい。 |
|
def n_gram(target, n):
return [target[idx:idx + n] for idx in range(len(target) - n + 1)]
X_text = 'paraparaparadise'
Y_text = 'paragraph'
X = n_gram(X_text, 2)
Y = n_gram(Y_text, 2)
print(f'和集合: {set(X) | set(Y)}')
print(f'積集合: {set(X) & set(Y)}')
print(f'差集合: {set(X) - set(Y)}')
print('se' in (set(X) & set(Y))) | code_generation | 561 | MIT | nlp_100_knocks | pythonを用いて、“paraparaparadise”と”paragraph”に含まれる文字bi-gramの集合を，それぞれ, XとYとして求め，XとYの和集合，積集合，差集合を求めよ．さらに，’se’というbi-gramがXおよびYに含まれるかどうかを調べなさい。 |
|
def generate_text(x, y, z):
return f'{x}時の{y}は{z}'
x = 12
y = '気温'
z = 22.4
print(generate_text(x, y, z)) | code_generation | 562 | MIT | nlp_100_knocks | pythonを用いて、引数x, y, zを受け取り「x時のyはz」という文字列を返す関数を実装せよ．さらに，x=12, y=”気温”, z=22.4として，実行結果を確認しなさい。 |
|
def cipher(text):
text = [chr(219 - ord(w)) if 97 <= ord(w) <= 122 else w for w in text]
return ''.join(text)
text = 'this is a message.'
ans = cipher(text)
print(ans)
ans = cipher(ans)
print(ans) | code_generation | 563 | MIT | nlp_100_knocks | pythonを用いて、与えられた文字列の各文字を，以下の仕様で変換する関数cipherを実装しなさい。
・英小文字ならば(219 - 文字コード)の文字に置換
・その他の文字はそのまま出力
また、この関数を用い，英語のメッセージを暗号化・復号化しなさい。 |
|
import random
def shuffle_word(word):
if len(word) <= 4:
return word
else:
start = word[0]
end = word[-1]
others = random.sample(list(word[1:-1]), len(word[1:-1]))
return ''.join([start] + others + [end])
text = 'I couldn’t believe that I could actually understand what I was reading : the phenomenal power of the human mind .'
ans = [shuffle_word(w) for w in text.split()]
print(' '.join(ans)) | code_generation | 564 | MIT | nlp_100_knocks | pythonを用いて、スペースで区切られた単語列に対して，各単語の先頭と末尾の文字は残し，それ以外の文字の順序をランダムに並び替えるプログラムを作成しなさい。ただし、長さが４以下の単語は並び替えないこととする。適当な英語の文（例えば”I couldn’t believe that I could actually understand what I was reading : the phenomenal power of the human mind .”）を与え、その実行結果を確認せよ。 |
|
import pandas as pd
df = pd.read_csv('ch02/popular-names.txt', sep='\t', header=None)
print(len(df))
wc -l ch02/popular-names.txt | code_generation | 565 | MIT | nlp_100_knocks | pythonを用いて、行数をカウントせよ．確認にはwcコマンドを用いよ。 |
|
import pandas as pd
df = pd.read_csv('ch02/popular-names.txt', sep='\t', header=None)
df.to_csv('ch02/ans11.txt', sep=' ', index=False, header=None)
sed -e 's/[[:cntrl:]]/ /g' ch02/popular-names.txt >> ch02/ans11.txt | code_generation | 566 | MIT | nlp_100_knocks | pythonを用いて、タブ1文字につきスペース1文字に置換せよ。確認にはsedコマンド、trコマンド、もしくはexpandコマンドを用いよ。 |
|
import pandas as pd
df = pd.read_csv('ch02/popular-names.txt', sep='\t', header=None)
df[0].to_csv('ch02/col1.txt', index=False, header=None)
df[1].to_csv('ch02/col2.txt', index=False, header=None)
cut -f1 -d$'\t' ch02/popular-names.txt >> ch02/col1.txt
cut -f2 -d$'\t' ch02/popular-names.txt >> ch02/col2.txt | code_generation | 567 | MIT | nlp_100_knocks | pythonを用いて、各行の1列目だけを抜き出したものをcol1.txtに、2列目だけを抜き出したものをcol2.txtとしてファイルに保存せよ。確認にはcutコマンドを用いよ。 |
|
import pandas as pd
c1 = pd.read_csv('ch02/col1.txt', header=None)
c2 = pd.read_csv('ch02/col2.txt', header=None)
df = pd.concat([c1, c2], axis=1)
df.to_csv('ch02/ans13.txt', sep='\t', index=False, header=None)
paste ch02/col1.txt ch02/col2.txt >> ch02/ans13.txt | code_generation | 568 | MIT | nlp_100_knocks | pythonを用いて、col1.txtとcol2.txtを結合し、元のファイルの1列目と2列目をタブ区切りで並べたテキストファイルを作成せよ。確認にはpasteコマンドを用いよ。
import pandas as pd
df = pd.read_csv('ch02/popular-names.txt', sep='\t', header=None)
df[0].to_csv('ch02/col1.txt', index=False, header=None)
df[1].to_csv('ch02/col2.txt', index=False, header=None) |
|
import sys
import pandas as pd
if len(sys.argv) == 1:
print('Set arg n, like "python ch02/ans14.py 5"')
else:
n = int(sys.argv[1])
df = pd.read_csv('ch02/popular-names.txt', sep='\t', header=None)
print(df.head(n))
head -n $1 ch02/popular-names.txt | code_generation | 569 | MIT | nlp_100_knocks | pythonを用いて、自然数Nをコマンドライン引数などの手段で受け取り、入力のうち先頭のN行だけを表示せよ。確認にはheadコマンドを用いよ。 |
|
import sys
import pandas as pd
if len(sys.argv) == 1:
print('Set arg n, like "python ch02/ans15.py 5"')
else:
n = int(sys.argv[1])
df = pd.read_csv('ch02/popular-names.txt', sep='\t', header=None)
print(df.tail(n))
tail -n $1 ch02/popular-names.txt | code_generation | 570 | MIT | nlp_100_knocks | pythonを用いて、自然数Nをコマンドライン引数などの手段で受け取り、入力のうち末尾のN行だけを表示せよ。確認にはtailコマンドを用いよ。 |
|
import sys
import pandas as pd
if len(sys.argv) == 1:
print('Set arg n, like "python ch02/ans15.py 5"')
else:
n = int(sys.argv[1])
df = pd.read_csv('ch02/popular-names.txt', sep='\t', header=None)
nrow = -(-len(df) // n)
for i in range(n):
df.loc[nrow * i:nrow * (i + 1)].to_csv(f'ch02/ans16_{i}', sep='\t', index=False, header=None)
n=`wc -l ch02/popular-names.txt | awk '{print $1}'`
ln=`expr $n / $1`
split -l $ln ch02/popular-names.txt ch02/ans16_ | code_generation | 571 | MIT | nlp_100_knocks | pythonを用いて、自然数Nをコマンドライン引数などの手段で受け取り、入力のファイルを行単位でN分割せよ。同様の処理をsplitコマンドで実現せよ。 |
|
import pandas as pd
df = pd.read_csv('ch02/popular-names.txt', sep='\t', header=None)
print(df[0].unique())
cut -f1 -d$'\t' ch02/popular-names.txt | LANG=C sort | uniq | code_generation | 572 | MIT | nlp_100_knocks | pythonを用いて、1列目の文字列の種類（異なる文字列の集合）を求めよ。確認にはcut、 sort、 uniqコマンドを用いよ。 |
|
import pandas as pd
df = pd.read_csv('ch02/popular-names.txt', sep='\t', header=None)
print(df.sort_values(2, ascending=False))
sort -r -k 3 -t $'\t' ch02/popular-names.txt | code_generation | 573 | MIT | nlp_100_knocks | pythonを用いて、各行を3コラム目の数値の逆順で整列せよ（注意: 各行の内容は変更せずに並び替えよ）。確認にはsortコマンドを用いよ（この問題はコマンドで実行した時の結果と合わなくてもよい）。 |
|
import pandas as pd
df = pd.read_csv('ch02/popular-names.txt', sep='\t', header=None)
print(df[0].value_counts())
cut -f1 -d$'\t' ch02/popular-names.txt | LANG=C sort | uniq -c | sort -r -k 2 -t ' ' | code_generation | 574 | MIT | nlp_100_knocks | pythonを用いて、各行の1列目の文字列の出現頻度を求め、その高い順に並べて表示せよ。確認にはcut、uniq、sortコマンドを用いよ。 |
|
import pandas as pd
df = pd.read_json('ch03/jawiki-country.json.gz', lines=True)
uk_text = df.query('title=="イギリス"')['text'].values[0]
print(uk_text) | code_generation | 575 | MIT | nlp_100_knocks | pythonを用いて、Wikipedia記事のJSONファイルを読み込み、「イギリス」に関する記事本文を表示せよ。問題21-29では、ここで抽出した記事本文に対して実行せよ。 |
|
import pandas as pd
df = pd.read_json('ch03/jawiki-country.json.gz', lines=True)
uk_text = df.query('title=="イギリス"')['text'].values[0]
uk_texts = uk_text.split('\n')
ans = list(filter(lambda x: '[Category:' in x, uk_texts))
print(ans) | code_generation | 576 | MIT | nlp_100_knocks | pythonを用いて、記事中でカテゴリ名を宣言している行を抽出せよ。 |
|
import pandas as pd
df = pd.read_json('ch03/jawiki-country.json.gz', lines=True)
uk_text = df.query('title=="イギリス"')['text'].values[0]
uk_texts = uk_text.split('\n')
ans = list(filter(lambda x: '[Category:' in x, uk_texts))
ans = [a.replace('[[Category:', '').replace('|*', '').replace(']]', '') for a in ans]
print(ans) | code_generation | 577 | MIT | nlp_100_knocks | pythonを用いて、記事のカテゴリ名を（行単位ではなく名前で）抽出せよ。 |
|
import re
import pandas as pd
df = pd.read_json('ch03/jawiki-country.json.gz', lines=True)
uk_text = df.query('title=="イギリス"')['text'].values[0]
for section in re.findall(r'(=+)([^=]+)\1\n', uk_text):
print(f'{section[1].strip()}\t{len(section[0]) - 1}') | code_generation | 578 | MIT | nlp_100_knocks | pythonを用いて、記事中に含まれるセクション名とそのレベル（例えば”== セクション名 ==”なら1）を表示せよ。 |
|
import re
import pandas as pd
df = pd.read_json('ch03/jawiki-country.json.gz', lines=True)
uk_text = df.query('title=="イギリス"')['text'].values[0]
for file in re.findall(r'\[\[(ファイル|File):([^]|]+?)(\|.*?)+\]\]', uk_text):
print(file[1]) | code_generation | 579 | MIT | nlp_100_knocks | pythonを用いて、記事から参照されているメディアファイルをすべて抜き出せ。 |
|
import re
import pandas as pd
df = pd.read_json('ch03/jawiki-country.json.gz', lines=True)
uk_text = df.query('title=="イギリス"')['text'].values[0]
uk_texts = uk_text.split('\n')
pattern = re.compile('\|(.+?)\s=\s*(.+)')
ans = {}
for line in uk_texts:
r = re.search(pattern, line)
if r:
ans[r[1]] = r[2]
print(ans) | code_generation | 580 | MIT | nlp_100_knocks | pythonを用いて、記事中に含まれる「基礎情報」テンプレートのフィールド名と値を抽出し、辞書オブジェクトとして格納せよ。 |
|
import re
import pandas as pd
def remove_stress(dc):
r = re.compile("'+")
return {k: r.sub('', v) for k, v in dc.items()}
df = pd.read_json('ch03/jawiki-country.json.gz', lines=True)
uk_text = df.query('title=="イギリス"')['text'].values[0]
uk_texts = uk_text.split('\n')
pattern = re.compile('\|(.+?)\s=\s*(.+)')
ans = {}
for line in uk_texts:
r = re.search(pattern, line)
if r:
ans[r[1]] = r[2]
print(remove_stress(ans)) | code_generation | 581 | MIT | nlp_100_knocks | pythonを用いて、記事中に含まれる「基礎情報」テンプレートのフィールド名と値を抽出し、辞書オブジェクトとして格納する処理時に、テンプレートの値からMediaWikiの強調マークアップ（弱い強調、強調、強い強調のすべて）を除去してテキストに変換せよ。 |
|
import re
import pandas as pd
def remove_stress(dc):
r = re.compile("'+")
return {k: r.sub('', v) for k, v in dc.items()}
def remove_inner_links(dc):
r = re.compile('\[\[(.+\||)(.+?)\]\]')
return {k: r.sub(r'\2', v) for k, v in dc.items()}
df = pd.read_json('ch03/jawiki-country.json.gz', lines=True)
uk_text = df.query('title=="イギリス"')['text'].values[0]
uk_texts = uk_text.split('\n')
pattern = re.compile('\|(.+?)\s=\s*(.+)')
ans = {}
for line in uk_texts:
r = re.search(pattern, line)
if r:
ans[r[1]] = r[2]
print(remove_inner_links(remove_stress(ans))) | code_generation | 582 | MIT | nlp_100_knocks | pythonを用いて、記事中に含まれる「基礎情報」テンプレートのフィールド名と値を抽出し、辞書オブジェクトとして格納し、テンプレートの値からMediaWikiの強調マークアップ（弱い強調、強調、強い強調のすべて）を除去してテキストに変換する処理時に、テンプレートの値からMediaWikiの内部リンクマークアップを除去し、テキストに変換せよ。 |
|
import re
import pandas as pd
def remove_stress(dc):
r = re.compile("'+")
return {k: r.sub('', v) for k, v in dc.items()}
def remove_inner_links(dc):
r = re.compile('\[\[(.+\||)(.+?)\]\]')
return {k: r.sub(r'\2', v) for k, v in dc.items()}
def remove_mk(v):
r1 = re.compile("'+")
r2 = re.compile('\[\[(.+\||)(.+?)\]\]')
r3 = re.compile('\{\{(.+\||)(.+?)\}\}')
r4 = re.compile('<\s*?/*?\s*?br\s*?/*?\s*>')
v = r1.sub('', v)
v = r2.sub(r'\2', v)
v = r3.sub(r'\2', v)
v = r4.sub('', v)
return v
df = pd.read_json('ch03/jawiki-country.json.gz', lines=True)
uk_text = df.query('title=="イギリス"')['text'].values[0]
uk_texts = uk_text.split('\n')
pattern = re.compile('\|(.+?)\s=\s*(.+)')
ans = {}
for line in uk_texts:
r = re.search(pattern, line)
if r:
ans[r[1]] = r[2]
r = re.compile('\[\[(.+\||)(.+?)\]\]')
ans = {k: r.sub(r'\2', remove_mk(v)) for k, v in ans.items()}
print(remove_inner_links(remove_stress(ans))) | code_generation | 583 | MIT | nlp_100_knocks | pythonを用いて、記事中に含まれる「基礎情報」テンプレートのフィールド名と値を抽出し、辞書オブジェクトとして格納し、テンプレートの値からMediaWikiの強調マークアップ（弱い強調、強調、強い強調のすべて）を除去してテキストに変換し、テンプレートの値からMediaWikiの内部リンクマークアップを除去し、テキストに変換する処理時に、テンプレートの値からMediaWikiマークアップを可能な限り除去し、国の基本情報を整形せよ。 |
|
import re
import requests
import pandas as pd
def remove_stress(dc):
r = re.compile("'+")
return {k: r.sub('', v) for k, v in dc.items()}
def remove_inner_links(dc):
r = re.compile('\[\[(.+\||)(.+?)\]\]')
return {k: r.sub(r'\2', v) for k, v in dc.items()}
def remove_mk(v):
r1 = re.compile("'+")
r2 = re.compile('\[\[(.+\||)(.+?)\]\]')
r3 = re.compile('\{\{(.+\||)(.+?)\}\}')
r4 = re.compile('<\s*?/*?\s*?br\s*?/*?\s*>')
v = r1.sub('', v)
v = r2.sub(r'\2', v)
v = r3.sub(r'\2', v)
v = r4.sub('', v)
return v
def get_url(dc):
url_file = dc['国旗画像'].replace(' ', '_')
url = 'https://commons.wikimedia.org/w/api.php?action=query&titles=File:' + url_file + '&prop=imageinfo&iiprop=url&format=json'
data = requests.get(url)
return re.search(r'"url":"(.+?)"', data.text).group(1)
df = pd.read_json('ch03/jawiki-country.json.gz', lines=True)
uk_text = df.query('title=="イギリス"')['text'].values[0]
uk_texts = uk_text.split('\n')
pattern = re.compile('\|(.+?)\s=\s*(.+)')
ans = {}
for line in uk_texts:
r = re.search(pattern, line)
if r:
ans[r[1]] = r[2]
r = re.compile('\[\[(.+\||)(.+?)\]\]')
ans = {k: r.sub(r'\2', remove_mk(v)) for k, v in ans.items()}
print(get_url(remove_inner_links(remove_stress(ans)))) | code_generation | 584 | MIT | nlp_100_knocks | pythonを用いて、テンプレートの内容を利用し、国旗画像のURLを取得せよ。 |
|
def parse_mecab(block):
res = []
for line in block.split('\n'):
if line == '':
return res
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
res.append(lineDict)
filename = 'ch04/neko.txt.mecab'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_mecab(block) for block in blocks]
print(blocks[5])
mecab < ch04/neko.txt > ch04/neko.txt.mecab | code_generation | 585 | MIT | nlp_100_knocks | pythonを用いて、形態素解析結果（neko.txt.mecab）を読み込むプログラムを実装せよ。ただし、各形態素は表層形（surface）、基本形（base）、品詞（pos）、品詞細分類1（pos1）をキーとするマッピング型に格納し、1文を形態素（マッピング型）のリストとして表現せよ。 |
|
def parse_mecab(block):
res = []
for line in block.split('\n'):
if line == '':
return res
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
res.append(lineDict)
def extract_surface(block):
res = list(filter(lambda x: x['pos'] == '動詞', block))
res = [r['surface'] for r in res]
return res
filename = 'ch04/neko.txt.mecab'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_mecab(block) for block in blocks]
ans = [extract_surface(block) for block in blocks]
print(ans[5]) | code_generation | 586 | MIT | nlp_100_knocks | pythonを用いて、動詞の表層形をすべて抽出せよ。 |
|
def parse_mecab(block):
res = []
for line in block.split('\n'):
if line == '':
return res
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
res.append(lineDict)
def extract_base(block):
res = list(filter(lambda x: x['pos'] == '動詞', block))
res = [r['base'] for r in res]
return res
filename = 'ch04/neko.txt.mecab'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_mecab(block) for block in blocks]
ans = [extract_base(block) for block in blocks]
print(ans[5]) | code_generation | 587 | MIT | nlp_100_knocks | pythonを用いて、動詞の基本形をすべて抽出せよ。 |
|
def parse_mecab(block):
res = []
for line in block.split('\n'):
if line == '':
return res
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
res.append(lineDict)
def extract_a_no_b(block):
res = []
for i in range(1, len(block) - 1):
if block[i - 1]['pos'] == '名詞' and block[i]['base'] == 'の' and block[i + 1]['pos'] == '名詞':
res.append(block[i - 1]['surface'] + block[i]['surface'] + block[i + 1]['surface'])
return res
filename = 'ch04/neko.txt.mecab'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_mecab(block) for block in blocks]
ans = [extract_a_no_b(block) for block in blocks]
print(ans) | code_generation | 588 | MIT | nlp_100_knocks | pythonを用いて、2つの名詞が「の」で連結されている名詞句を抽出せよ。 |
|
def parse_mecab(block):
res = []
for line in block.split('\n'):
if line == '':
return res
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
res.append(lineDict)
def extract_noun_noun(block):
res = []
tmp = []
for b in block:
if b['pos'] == '名詞':
tmp.append(b['surface'])
elif len(tmp) >= 2:
res.append(''.join(tmp))
tmp = []
else:
tmp = []
return res
filename = 'ch04/neko.txt.mecab'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_mecab(block) for block in blocks]
ans = [extract_noun_noun(block) for block in blocks]
print(ans) | code_generation | 589 | MIT | nlp_100_knocks | pythonを用いて、文章中に出現する単語とその出現頻度を求め、出現頻度の高い順に並べよ。 |
|
from collections import defaultdict
def parse_mecab(block):
res = []
for line in block.split('\n'):
if line == '':
return res
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
res.append(lineDict)
def extract_words(block):
return [b['base'] + '_' + b['pos'] + '_' + b['pos1'] for b in block]
filename = 'ch04/neko.txt.mecab'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_mecab(block) for block in blocks]
words = [extract_words(block) for block in blocks]
d = defaultdict(int)
for word in words:
for w in word:
d[w] += 1
ans = sorted(d.items(), key=lambda x: x[1], reverse=True)
print(ans) | code_generation | 590 | MIT | nlp_100_knocks | pythonを用いて、文章中に出現する単語とその出現頻度を求め、出現頻度の高い順に並べよ。 |
|
from collections import defaultdict
import matplotlib.pyplot as plt
import japanize_matplotlib
def parse_mecab(block):
res = []
for line in block.split('\n'):
if line == '':
return res
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
res.append(lineDict)
def extract_words(block):
return [b['base'] + '_' + b['pos'] + '_' + b['pos1'] for b in block]
filename = 'ch04/neko.txt.mecab'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_mecab(block) for block in blocks]
words = [extract_words(block) for block in blocks]
d = defaultdict(int)
for word in words:
for w in word:
d[w] += 1
ans = sorted(d.items(), key=lambda x: x[1], reverse=True)[:10]
labels = [a[0] for a in ans]
values = [a[1] for a in ans]
plt.figure(figsize=(15, 8))
plt.barh(labels, values)
plt.savefig('ch04/ans36.png') | code_generation | 591 | MIT | nlp_100_knocks | pythonを用いて、出現頻度が高い10語とその出現頻度をグラフ（例えば棒グラフなど）で表示せよ。 |
|
from collections import defaultdict
import matplotlib.pyplot as plt
import japanize_matplotlib
def parse_mecab(block):
res = []
for line in block.split('\n'):
if line == '':
return res
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
res.append(lineDict)
def extract_base(block):
return [b['base'] for b in block]
filename = 'ch04/neko.txt.mecab'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_mecab(block) for block in blocks]
words = [extract_base(block) for block in blocks]
words = list(filter(lambda x: '猫' in x, words))
d = defaultdict(int)
for word in words:
for w in word:
if w != '猫':
d[w] += 1
ans = sorted(d.items(), key=lambda x: x[1], reverse=True)[:10]
labels = [a[0] for a in ans]
values = [a[1] for a in ans]
plt.figure(figsize=(8, 8))
plt.barh(labels, values)
plt.savefig('ch04/ans37.png') | code_generation | 592 | MIT | nlp_100_knocks | pythonを用いて、「猫」とよく共起する（共起頻度が高い）10語とその出現頻度をグラフ（例えば棒グラフなど）で表示せよ。 |
|
from collections import defaultdict
import matplotlib.pyplot as plt
def parse_mecab(block):
res = []
for line in block.split('\n'):
if line == '':
return res
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
res.append(lineDict)
def extract_words(block):
return [b['base'] + '_' + b['pos'] + '_' + b['pos1'] for b in block]
filename = 'ch04/neko.txt.mecab'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_mecab(block) for block in blocks]
words = [extract_words(block) for block in blocks]
d = defaultdict(int)
for word in words:
for w in word:
d[w] += 1
ans = d.values()
plt.figure(figsize=(8, 8))
plt.hist(ans, bins=100)
plt.savefig('ch04/ans38.png') | code_generation | 593 | MIT | nlp_100_knocks | pythonを用いて、単語の出現頻度のヒストグラムを描け。ただし、横軸は出現頻度を表し、1から単語の出現頻度の最大値までの線形目盛とする。縦軸はx軸で示される出現頻度となった単語の異なり数（種類数）である。 |
|
import math
from collections import defaultdict
import matplotlib.pyplot as plt
def parse_mecab(block):
res = []
for line in block.split('\n'):
if line == '':
return res
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
res.append(lineDict)
def extract_words(block):
return [b['base'] + '_' + b['pos'] + '_' + b['pos1'] for b in block]
filename = 'ch04/neko.txt.mecab'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_mecab(block) for block in blocks]
words = [extract_words(block) for block in blocks]
d = defaultdict(int)
for word in words:
for w in word:
d[w] += 1
ans = sorted(d.items(), key=lambda x: x[1], reverse=True)
ranks = [math.log(r + 1) for r in range(len(ans))]
values = [math.log(a[1]) for a in ans]
plt.figure(figsize=(8, 8))
plt.scatter(ranks, values)
plt.savefig('ch04/ans39.png') | code_generation | 594 | MIT | nlp_100_knocks | pythonを用いて、単語の出現頻度順位を横軸、その出現頻度を縦軸として、両対数グラフをプロットせよ。 |
|
class Morph:
def __init__(self, dc):
self.surface = dc['surface']
self.base = dc['base']
self.pos = dc['pos']
self.pos1 = dc['pos1']
def parse_cabocha(block):
res = []
for line in block.split('\n'):
if line == '':
return res
elif line[0] == '*':
continue
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
res.append(Morph(lineDict))
filename = 'ch05/ai.ja.txt.cabocha'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_cabocha(block) for block in blocks]
for m in blocks[2]:
print(vars(m)) | code_generation | 595 | MIT | nlp_100_knocks | pythonを用いて、形態素を表すクラスMorphを実装せよ。このクラスは表層形（surface）、基本形（base）、品詞（pos）、品詞細分類1（pos1）をメンバ変数に持つこととする。さらに、係り受け解析の結果（ai.ja.txt.parsed）を読み込み、各文をMorphオブジェクトのリストとして表現し、冒頭の説明文の形態素列を表示せよ。 |
|
class Morph:
def __init__(self, dc):
self.surface = dc['surface']
self.base = dc['base']
self.pos = dc['pos']
self.pos1 = dc['pos1']
class Chunk:
def __init__(self, morphs, dst):
self.morphs = morphs # 形態素（Morphオブジェクト）のリスト
self.dst = dst # 係り先文節インデックス番号
self.srcs = [] # 係り元文節インデックス番号のリスト
def parse_cabocha(block):
def check_create_chunk(tmp):
if len(tmp) > 0:
c = Chunk(tmp, dst)
res.append(c)
tmp = []
return tmp
res = []
tmp = []
dst = None
for line in block.split('\n'):
if line == '':
tmp = check_create_chunk(tmp)
elif line[0] == '*':
dst = line.split(' ')[2].rstrip('D')
tmp = check_create_chunk(tmp)
else:
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
tmp.append(Morph(lineDict))
for i, r in enumerate(res):
res[int(r.dst)].srcs.append(i)
return res
filename = 'ch05/ai.ja.txt.cabocha'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_cabocha(block) for block in blocks]
for m in blocks[7]:
print([mo.surface for mo in m.morphs], m.dst, m.srcs) | code_generation | 596 | MIT | nlp_100_knocks | pythonを用いて、形態素を表すクラスMorphと文節を表すクラスChunkを実装せよ。このクラスは形態素（Morphオブジェクト）のリスト（morphs）、係り先文節インデックス番号（dst）、係り元文節インデックス番号のリスト（srcs）をメンバ変数に持つこととする。さらに、入力テキストの係り受け解析結果を読み込み、１文をChunkオブジェクトのリストとして表現し、冒頭の説明文の文節の文字列と係り先を表示せよ。本章の残りの問題では、ここで作ったプログラムを活用せよ。 |
|
class Morph:
def __init__(self, dc):
self.surface = dc['surface']
self.base = dc['base']
self.pos = dc['pos']
self.pos1 = dc['pos1']
class Chunk:
def __init__(self, morphs, dst):
self.morphs = morphs # 形態素（Morphオブジェクト）のリスト
self.dst = dst # 係り先文節インデックス番号
self.srcs = [] # 係り元文節インデックス番号のリスト
def parse_cabocha(block):
def check_create_chunk(tmp):
if len(tmp) > 0:
c = Chunk(tmp, dst)
res.append(c)
tmp = []
return tmp
res = []
tmp = []
dst = None
for line in block.split('\n'):
if line == '':
tmp = check_create_chunk(tmp)
elif line[0] == '*':
dst = line.split(' ')[2].rstrip('D')
tmp = check_create_chunk(tmp)
else:
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
tmp.append(Morph(lineDict))
for i, r in enumerate(res):
res[int(r.dst)].srcs.append(i)
return res
filename = 'ch05/ai.ja.txt.cabocha'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_cabocha(block) for block in blocks]
for b in blocks:
for m in b:
if int(m.dst) > -1:
print(''.join([mo.surface if mo.pos != '記号' else '' for mo in m.morphs]),
''.join([mo.surface if mo.pos != '記号' else '' for mo in b[int(m.dst)].morphs]), sep='\t') | code_generation | 597 | MIT | nlp_100_knocks | pythonを用いて、係り元の文節と係り先の文節のテキストをタブ区切り形式ですべて抽出せよ。ただし、句読点などの記号は出力しないようにせよ。 |
|
class Morph:
def __init__(self, dc):
self.surface = dc['surface']
self.base = dc['base']
self.pos = dc['pos']
self.pos1 = dc['pos1']
class Chunk:
def __init__(self, morphs, dst):
self.morphs = morphs # 形態素（Morphオブジェクト）のリスト
self.dst = dst # 係り先文節インデックス番号
self.srcs = [] # 係り元文節インデックス番号のリスト
def parse_cabocha(block):
def check_create_chunk(tmp):
if len(tmp) > 0:
c = Chunk(tmp, dst)
res.append(c)
tmp = []
return tmp
res = []
tmp = []
dst = None
for line in block.split('\n'):
if line == '':
tmp = check_create_chunk(tmp)
elif line[0] == '*':
dst = line.split(' ')[2].rstrip('D')
tmp = check_create_chunk(tmp)
else:
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
tmp.append(Morph(lineDict))
for i, r in enumerate(res):
res[int(r.dst)].srcs.append(i)
return res
filename = 'ch05/ai.ja.txt.cabocha'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_cabocha(block) for block in blocks]
for b in blocks:
for m in b:
if int(m.dst) > -1:
pre_text = ''.join([mo.surface if mo.pos != '記号' else '' for mo in m.morphs])
pre_pos = [mo.pos for mo in m.morphs]
post_text = ''.join([mo.surface if mo.pos != '記号' else '' for mo in b[int(m.dst)].morphs])
post_pos = [mo.pos for mo in b[int(m.dst)].morphs]
if '名詞' in pre_pos and '動詞' in post_pos:
print(pre_text, post_text, sep='\t') | code_generation | 598 | MIT | nlp_100_knocks | pythonを用いて、名詞を含む文節が、動詞を含む文節に係るとき、これらをタブ区切り形式で抽出せよ。ただし、句読点などの記号は出力しないようにせよ。 |
|
import pydot
class Morph:
def __init__(self, dc):
self.surface = dc['surface']
self.base = dc['base']
self.pos = dc['pos']
self.pos1 = dc['pos1']
class Chunk:
def __init__(self, morphs, dst):
self.morphs = morphs # 形態素（Morphオブジェクト）のリスト
self.dst = dst # 係り先文節インデックス番号
self.srcs = [] # 係り元文節インデックス番号のリスト
def parse_cabocha(block):
def check_create_chunk(tmp):
if len(tmp) > 0:
c = Chunk(tmp, dst)
res.append(c)
tmp = []
return tmp
res = []
tmp = []
dst = None
for line in block.split('\n'):
if line == '':
tmp = check_create_chunk(tmp)
elif line[0] == '*':
dst = line.split(' ')[2].rstrip('D')
tmp = check_create_chunk(tmp)
else:
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
tmp.append(Morph(lineDict))
for i, r in enumerate(res):
res[int(r.dst)].srcs.append(i)
return res
filename = 'ch05/ai.ja.txt.cabocha'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_cabocha(block) for block in blocks]
pairs = []
target = blocks[7]
for m in target:
if int(m.dst) > -1:
pre_text = ''.join([mo.surface if mo.pos != '記号' else '' for mo in m.morphs])
post_text = ''.join([mo.surface if mo.pos != '記号' else '' for mo in target[int(m.dst)].morphs])
pairs.append([pre_text, post_text])
print(pairs)
g = pydot.graph_from_edges(pairs)
g.write_png('ch05/ans44.png', prog='dot') | code_generation | 599 | MIT | nlp_100_knocks | pythonを用いて、与えられた文の係り受け木を有向グラフとして可視化せよ。可視化には、Graphviz等を用いるとよい。 |
|
class Morph:
def __init__(self, dc):
self.surface = dc['surface']
self.base = dc['base']
self.pos = dc['pos']
self.pos1 = dc['pos1']
class Chunk:
def __init__(self, morphs, dst):
self.morphs = morphs # 形態素（Morphオブジェクト）のリスト
self.dst = dst # 係り先文節インデックス番号
self.srcs = [] # 係り元文節インデックス番号のリスト
def parse_cabocha(block):
def check_create_chunk(tmp):
if len(tmp) > 0:
c = Chunk(tmp, dst)
res.append(c)
tmp = []
return tmp
res = []
tmp = []
dst = None
for line in block.split('\n'):
if line == '':
tmp = check_create_chunk(tmp)
elif line[0] == '*':
dst = line.split(' ')[2].rstrip('D')
tmp = check_create_chunk(tmp)
else:
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
tmp.append(Morph(lineDict))
for i, r in enumerate(res):
res[int(r.dst)].srcs.append(i)
return res
filename = 'ch05/ai.ja.txt.cabocha'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_cabocha(block) for block in blocks]
for b in blocks:
for m in b:
if len(m.srcs) > 0:
pre_morphs = [b[int(s)].morphs for s in m.srcs]
pre_morphs = [list(filter(lambda x: '助詞' in x.pos, pm)) for pm in pre_morphs]
pre_surface = [[p.surface for p in pm] for pm in pre_morphs]
pre_surface = list(filter(lambda x: x != [], pre_surface))
pre_surface = [p[0] for p in pre_surface]
post_base = [mo.base for mo in m.morphs]
post_pos = [mo.pos for mo in m.morphs]
if len(pre_surface) > 0 and '動詞' in post_pos:
print(post_base[0], ' '.join(pre_surface), sep='\t') | code_generation | 600 | MIT | nlp_100_knocks | pythonを用いて、今回用いている文章をコーパスと見なし、日本語の述語が取りうる格を調査したい。 動詞を述語、動詞に係っている文節の助詞を格と考え、述語と格をタブ区切り形式で出力せよ。 ただし、出力は以下の仕様を満たすようにせよ。
・動詞を含む文節において、最左の動詞の基本形を述語とする
・述語に係る助詞を格とする
・述語に係る助詞（文節）が複数あるときは、すべての助詞をスペース区切りで辞書順に並べる
「ジョン・マッカーシーはAIに関する最初の会議で人工知能という用語を作り出した。」という例文を考える。 この文は「作り出す」という１つの動詞を含み、「作り出す」に係る文節は「ジョン・マッカーシーは」、「会議で」、「用語を」であると解析された場合は、次のような出力になるはずである。
```
作り出す で は を
このプログラムの出力をファイルに保存し、以下の事項をUNIXコマンドを用いて確認せよ。
```
・コーパス中で頻出する述語と格パターンの組み合わせ
・「行う」「なる」「与える」という動詞の格パターン（コーパス中で出現頻度の高い順に並べよ） |
|
class Morph:
def __init__(self, dc):
self.surface = dc['surface']
self.base = dc['base']
self.pos = dc['pos']
self.pos1 = dc['pos1']
class Chunk:
def __init__(self, morphs, dst):
self.morphs = morphs # 形態素（Morphオブジェクト）のリスト
self.dst = dst # 係り先文節インデックス番号
self.srcs = [] # 係り元文節インデックス番号のリスト
def parse_cabocha(block):
def check_create_chunk(tmp):
if len(tmp) > 0:
c = Chunk(tmp, dst)
res.append(c)
tmp = []
return tmp
res = []
tmp = []
dst = None
for line in block.split('\n'):
if line == '':
tmp = check_create_chunk(tmp)
elif line[0] == '*':
dst = line.split(' ')[2].rstrip('D')
tmp = check_create_chunk(tmp)
else:
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
tmp.append(Morph(lineDict))
for i, r in enumerate(res):
res[int(r.dst)].srcs.append(i)
return res
filename = 'ch05/ai.ja.txt.cabocha'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_cabocha(block) for block in blocks]
for b in blocks:
for m in b:
if len(m.srcs) > 0:
pre_morphs = [b[int(s)].morphs for s in m.srcs]
pre_morphs_filtered = [list(filter(lambda x: '助詞' in x.pos, pm)) for pm in pre_morphs]
pre_surface = [[p.surface for p in pm] for pm in pre_morphs_filtered]
pre_surface = list(filter(lambda x: x != [], pre_surface))
pre_surface = [p[0] for p in pre_surface]
post_base = [mo.base for mo in m.morphs]
post_pos = [mo.pos for mo in m.morphs]
if len(pre_surface) > 0 and '動詞' in post_pos:
pre_text = list(filter(lambda x: '助詞' in [p.pos for p in x], pre_morphs))
pre_text = [''.join([p.surface for p in pt]) for pt in pre_text]
print(post_base[0], ' '.join(pre_surface), ' '.join(pre_text), sep='\t') | code_generation | 601 | MIT | nlp_100_knocks | pythonを用いて、45のプログラムを改変し、述語と格パターンに続けて項（述語に係っている文節そのもの）をタブ区切り形式で出力せよ。45の仕様に加えて、以下の仕様を満たすようにせよ。
・項は述語に係っている文節の単語列とする（末尾の助詞を取り除く必要はない）
・述語に係る文節が複数あるときは、助詞と同一の基準・順序でスペース区切りで並べる
「ジョン・マッカーシーはAIに関する最初の会議で人工知能という用語を作り出した。」という例文を考える。 この文は「作り出す」という１つの動詞を含み、「作り出す」に係る文節は「ジョン・マッカーシーは」、「会議で」、「用語を」であると解析された場合は、次のような出力になるはずである。
```
作り出す で は を 会議で ジョンマッカーシーは 用語を
``` |
|
class Morph:
def __init__(self, dc):
self.surface = dc['surface']
self.base = dc['base']
self.pos = dc['pos']
self.pos1 = dc['pos1']
class Chunk:
def __init__(self, morphs, dst):
self.morphs = morphs # 形態素（Morphオブジェクト）のリスト
self.dst = dst # 係り先文節インデックス番号
self.srcs = [] # 係り元文節インデックス番号のリスト
def parse_cabocha(block):
def check_create_chunk(tmp):
if len(tmp) > 0:
c = Chunk(tmp, dst)
res.append(c)
tmp = []
return tmp
res = []
tmp = []
dst = None
for line in block.split('\n'):
if line == '':
tmp = check_create_chunk(tmp)
elif line[0] == '*':
dst = line.split(' ')[2].rstrip('D')
tmp = check_create_chunk(tmp)
else:
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
tmp.append(Morph(lineDict))
for i, r in enumerate(res):
res[int(r.dst)].srcs.append(i)
return res
filename = 'ch05/ai.ja.txt.cabocha'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_cabocha(block) for block in blocks]
with open('ch05/ans47.txt', mode='w') as f:
for b in blocks:
for i, m in enumerate(b):
if 'サ変接続' in [s.pos1 for s in m.morphs] and 'を' in [s.surface for s in m.morphs] and i + 1 < len(b) and b[i + 1].morphs[0].pos == '動詞':
text = ''.join([s.surface for s in m.morphs]) + b[i + 1].morphs[0].base
if len(m.srcs) > 0:
pre_morphs = [b[int(s)].morphs for s in m.srcs]
pre_morphs_filtered = [list(filter(lambda x: '助詞' in x.pos, pm)) for pm in pre_morphs]
pre_surface = [[p.surface for p in pm] for pm in pre_morphs_filtered]
pre_surface = list(filter(lambda x: x != [], pre_surface))
pre_surface = [p[0] for p in pre_surface]
pre_text = list(filter(lambda x: '助詞' in [p.pos for p in x], pre_morphs))
pre_text = [''.join([p.surface for p in pt]) for pt in pre_text]
if len(pre_surface) > 0:
f.writelines('\t'.join([text, ' '.join(pre_surface), ' '.join(pre_text)]))
f.write('\n') | code_generation | 602 | MIT | nlp_100_knocks | pythonを用いて、動詞のヲ格にサ変接続名詞が入っている場合のみに着目したい。46のプログラムを以下の仕様を満たすように改変せよ。
・「サ変接続名詞+を（助詞）」で構成される文節が動詞に係る場合のみを対象とする
・述語は「サ変接続名詞+を+動詞の基本形」とし、文節中に複数の動詞があるときは、最左の動詞を用いる
・述語に係る助詞（文節）が複数あるときは、すべての助詞をスペース区切りで辞書順に並べる
・述語に係る文節が複数ある場合は、すべての項をスペース区切りで並べる（助詞の並び順と揃えよ）
例えば「また、自らの経験を元に学習を行う強化学習という手法もある。」という文から、以下の出力が得られるはずである。
```
学習を行う に を 元に 経験を
``` |
|
class Morph:
def __init__(self, dc):
self.surface = dc['surface']
self.base = dc['base']
self.pos = dc['pos']
self.pos1 = dc['pos1']
class Chunk:
def __init__(self, morphs, dst):
self.morphs = morphs # 形態素（Morphオブジェクト）のリスト
self.dst = dst # 係り先文節インデックス番号
self.srcs = [] # 係り元文節インデックス番号のリスト
def parse_cabocha(block):
def check_create_chunk(tmp):
if len(tmp) > 0:
c = Chunk(tmp, dst)
res.append(c)
tmp = []
return tmp
res = []
tmp = []
dst = None
for line in block.split('\n'):
if line == '':
tmp = check_create_chunk(tmp)
elif line[0] == '*':
dst = line.split(' ')[2].rstrip('D')
tmp = check_create_chunk(tmp)
else:
(surface, attr) = line.split('\t')
attr = attr.split(',')
lineDict = {
'surface': surface,
'base': attr[6],
'pos': attr[0],
'pos1': attr[1]
}
tmp.append(Morph(lineDict))
for i, r in enumerate(res):
res[int(r.dst)].srcs.append(i)
return res
filename = 'ch05/ai.ja.txt.cabocha'
with open(filename, mode='rt', encoding='utf-8') as f:
blocks = f.read().split('EOS\n')
blocks = list(filter(lambda x: x != '', blocks))
blocks = [parse_cabocha(block) for block in blocks]
for b in blocks:
for m in b:
text = []
if '名詞' in [s.pos for s in m.morphs] and int(m.dst) != -1:
current_chunk = m
text.append(''.join([m.surface for m in current_chunk.morphs]))
next_chunk = b[int(current_chunk.dst)]
while int(current_chunk.dst) != -1:
text.append(''.join([m.surface for m in next_chunk.morphs]))
current_chunk = next_chunk
next_chunk = b[int(next_chunk.dst)]
print(*text, sep=' -> ') | code_generation | 603 | MIT | nlp_100_knocks | pythonを用いて、文中のすべての名詞を含む文節に対し、その文節から構文木の根に至るパスを抽出せよ。 ただし、構文木上のパスは以下の仕様を満たすものとする。
・各文節は（表層形の）形態素列で表現する
・パスの開始文節から終了文節に至るまで、各文節の表現を” -> “で連結する
「ジョン・マッカーシーはAIに関する最初の会議で人工知能という用語を作り出した。」という例文を考える。 CaboChaを係り受け解析に用いた場合、次のような出力が得られると思われる。
```
ジョンマッカーシーは -> 作り出した
AIに関する -> 最初の -> 会議で -> 作り出した
最初の -> 会議で -> 作り出した
会議で -> 作り出した
人工知能という -> 用語を -> 作り出した
用語を -> 作り出した
```
KNPを係り受け解析に用いた場合、次のような出力が得られると思われる。
```
ジョンマッカーシーは -> 作り出した
ＡＩに -> 関する -> 会議で -> 作り出した
会議で -> 作り出した
人工知能と -> いう -> 用語を -> 作り出した
用語を -> 作り出した
``` |
|
文中のすべての名詞句のペアを結ぶ最短係り受けパスを抽出せよ．ただし，名詞句ペアの文節番号がi
とj
（i<j
）のとき，係り受けパスは以下の仕様を満たすものとする．
問題48と同様に，パスは開始文節から終了文節に至るまでの各文節の表現（表層形の形態素列）を” -> “で連結して表現する
文節i
とj
に含まれる名詞句はそれぞれ，XとYに置換する
また，係り受けパスの形状は，以下の2通りが考えられる．
文節i
から構文木の根に至る経路上に文節j
が存在する場合: 文節i
から文節j
のパスを表示
上記以外で，文節i
と文節j
から構文木の根に至る経路上で共通の文節k
で交わる場合: 文節i
から文節k
に至る直前のパスと文節j
から文節k
に至る直前までのパス，文節k
の内容を” | “で連結して表示
「ジョン・マッカーシーはAIに関する最初の会議で人工知能という用語を作り出した。」という例文を考える． CaboChaを係り受け解析に用いた場合，次のような出力が得られると思われる．
Xは | Yに関する -> 最初の -> 会議で | 作り出した
Xは | Yの -> 会議で | 作り出した
Xは | Yで | 作り出した
Xは | Yという -> 用語を | 作り出した
Xは | Yを | 作り出した
Xに関する -> Yの
Xに関する -> 最初の -> Yで
Xに関する -> 最初の -> 会議で | Yという -> 用語を | 作り出した
Xに関する -> 最初の -> 会議で | Yを | 作り出した
Xの -> Yで
Xの -> 会議で | Yという -> 用語を | 作り出した
Xの -> 会議で | Yを | 作り出した
Xで | Yという -> 用語を | 作り出した
Xで | Yを | 作り出した
Xという -> Yを
KNPを係り受け解析に用いた場合，次のような出力が得られると思われる．
Xは | Yに -> 関する -> 会議で | 作り出した。
Xは | Yで | 作り出した。
Xは | Yと -> いう -> 用語を | 作り出した。
Xは | Yを | 作り出した。
Xに -> 関する -> Yで
Xに -> 関する -> 会議で | Yと -> いう -> 用語を | 作り出した。
Xに -> 関する -> 会議で | Yを | 作り出した。
Xで | Yと -> いう -> 用語を | 作り出した。
Xで | Yを | 作り出した。
Xと -> いう -> Yを | code_generation | 604 | MIT | nlp_100_knocks | pythonを用いて、文中のすべての名詞句のペアを結ぶ最短係り受けパスを抽出せよ。ただし、名詞句ペアの文節番号がiとj（i<j）のとき、係り受けパスは以下の仕様を満たすものとする。
・パスは開始文節から終了文節に至るまでの各文節の表現（表層形の形態素列）を” -> “で連結して表現する
・文節iとjに含まれる名詞句はそれぞれ、XとYに置換する
また、係り受けパスの形状は、以下の2通りが考えられる。
・文節iから構文木の根に至る経路上に文節jが存在する場合: 文節iから文節jのパスを表示
・上記以外で、文節iと文節jから構文木の根に至る経路上で共通の文節kで交わる場合: 文節iから文節kに至る直前のパスと文節jから文節kに至る直前までのパス、文節kの内容を” | “で連結して表示
「ジョン・マッカーシーはAIに関する最初の会議で人工知能という用語を作り出した。」という例文を考える。 CaboChaを係り受け解析に用いた場合、次のような出力が得られると思われる。
```
Xは | Yに関する -> 最初の -> 会議で | 作り出した
Xは | Yの -> 会議で | 作り出した
Xは | Yで | 作り出した
Xは | Yという -> 用語を | 作り出した
Xは | Yを | 作り出した
Xに関する -> Yの
Xに関する -> 最初の -> Yで
Xに関する -> 最初の -> 会議で | Yという -> 用語を | 作り出した
Xに関する -> 最初の -> 会議で | Yを | 作り出した
Xの -> Yで
Xの -> 会議で | Yという -> 用語を | 作り出した
Xの -> 会議で | Yを | 作り出した
Xで | Yという -> 用語を | 作り出した
Xで | Yを | 作り出した
Xという -> Yを
```
KNPを係り受け解析に用いた場合、次のような出力が得られると思われる。
```
Xは | Yに -> 関する -> 会議で | 作り出した。
Xは | Yで | 作り出した。
Xは | Yと -> いう -> 用語を | 作り出した。
Xは | Yを | 作り出した。
Xに -> 関する -> Yで
Xに -> 関する -> 会議で | Yと -> いう -> 用語を | 作り出した。
Xに -> 関する -> 会議で | Yを | 作り出した。
Xで | Yと -> いう -> 用語を | 作り出した。
Xで | Yを | 作り出した。
Xと -> いう -> Yを
``` |
|
import pandas as pd
from sklearn.model_selection import train_test_split
newsCorpora = pd.read_table('ch06/NewsAggregatorDataset/newsCorpora.csv', header=None)
newsCorpora.columns = ['ID', 'TITLE', 'URL', 'PUBLISHER', 'CATEGORY', 'STORY', 'HOSTNAME', 'TIMESTAMP']
newsCorpora = newsCorpora[newsCorpora['PUBLISHER'].isin(
['Reuters', 'Huffington Post', 'Businessweek', 'Contactmusic.com', 'Daily Mail'])].sample(frac=1, random_state=0)
X = newsCorpora[['TITLE', 'CATEGORY']].copy()
X['CATEGORY'] = X['CATEGORY'].map({'b': 0, 'e': 1, 't': 2, 'm': 3})
y = newsCorpora['CATEGORY']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=0)
X_valid, X_test, y_valid, y_test = train_test_split(X_test, y_test, test_size=0.5, stratify=y_test, random_state=0)
X_train.to_csv('ch06/train2.txt', sep='\t', index=False, header=None)
X_valid.to_csv('ch06/valid2.txt', sep='\t', index=False, header=None)
X_test.to_csv('ch06/test2.txt', sep='\t', index=False, header=None) | code_generation | 605 | MIT | nlp_100_knocks | pythonを用いて、News Aggregator Data Setをダウンロードし、以下の要領で学習データ（train.txt）、検証データ（valid.txt）、評価データ（test.txt）を作成せよ。
1.ダウンロードしたzipファイルを解凍し、readme.txtの説明を読む。
2.情報源（publisher）が”Reuters”, “Huffington Post”, “Businessweek”, “Contactmusic.com”, “Daily Mail”の事例（記事）のみを抽出する。
3.抽出された事例をランダムに並び替える。
4.抽出された事例の80%を学習データ、残りの10%ずつを検証データと評価データに分割し、それぞれtrain.txt、valid.txt、test.txtというファイル名で保存する。ファイルには、１行に１事例を書き出すこととし、カテゴリ名と記事見出しのタブ区切り形式とせよ（このファイルは後に問題70で再利用する）。
学習データと評価データを作成したら、各カテゴリの事例数を確認せよ。 |
|
import joblib
import pandas as pd
from sklearn.feature_extraction.text import CountVectorizer
X_train = pd.read_table('ch06/train.txt', header=None)
X_valid = pd.read_table('ch06/valid.txt', header=None)
X_test = pd.read_table('ch06/test.txt', header=None)
use_cols = ['TITLE', 'CATEGORY']
X_train.columns = use_cols
X_valid.columns = use_cols
X_test.columns = use_cols
X_train['TMP'] = 'train'
X_valid['TMP'] = 'valid'
X_test['TMP'] = 'test'
data = pd.concat([X_train, X_valid, X_test]).reset_index(drop=True)
vectorizer = CountVectorizer(token_pattern=u'(?u)\\b\\w+\\b')
bag = vectorizer.fit_transform(data['TITLE'])
data = pd.concat([data, pd.DataFrame(bag.toarray())], axis=1)
joblib.dump(vectorizer.vocabulary_, 'ch06/vocabulary_.joblib')
X_train = data.query('TMP=="train"').drop(use_cols + ['TMP'], axis=1)
X_valid = data.query('TMP=="valid"').drop(use_cols + ['TMP'], axis=1)
X_test = data.query('TMP=="test"').drop(use_cols + ['TMP'], axis=1)
X_train.to_csv('ch06/train.feature.txt', sep='\t', index=False, header=None)
X_valid.to_csv('ch06/valid.feature.txt', sep='\t', index=False, header=None)
X_test.to_csv('ch06/test.feature.txt', sep='\t', index=False, header=None) | code_generation | 606 | MIT | nlp_100_knocks | pythonを用いて、学習データ、検証データ、評価データから特徴量を抽出し、それぞれtrain.feature.txt、valid.feature.txt、test.feature.txtというファイル名で保存せよ。 なお、カテゴリ分類に有用そうな特徴量は各自で自由に設計せよ。記事の見出しを単語列に変換したものが最低限のベースラインとなるであろう。 |
|
import pandas as pd
import joblib
from sklearn.linear_model import LogisticRegression
X_train = pd.read_table('ch06/train.feature.txt', header=None)
y_train = pd.read_table('ch06/train.txt', header=None)[1]
clf = LogisticRegression(penalty='l2', solver='sag', random_state=0)
clf.fit(X_train, y_train)
joblib.dump(clf, 'ch06/model.joblib') | code_generation | 607 | MIT | nlp_100_knocks | pythonを用いて、学習データを用いて、ロジスティック回帰モデルを学習せよ。 |
|
import pandas as pd
from sklearn.linear_model import LogisticRegression
X_train = pd.read_table('ch06/train.feature.txt', header=None)
y_train = pd.read_table('ch06/train.txt', header=None)[1]
clf = LogisticRegression(penalty='l2', solver='sag', random_state=0)
clf.fit(X_train, y_train)
y_train = clf.predict(X_train) | code_generation | 608 | MIT | nlp_100_knocks | pythonを用いて、学習データから作成したロジスティック回帰モデルを用い、与えられた記事見出しからカテゴリとその予測確率を計算するプログラムを実装せよ。 |
|
import pandas as pd
import joblib
from sklearn.metrics import accuracy_score
X_train = pd.read_table('ch06/train.feature.txt', header=None)
X_test = pd.read_table('ch06/test.feature.txt', header=None)
y_train = pd.read_table('ch06/train.txt', header=None)[1]
y_test = pd.read_table('ch06/test.txt', header=None)[1]
clf = joblib.load('ch06/model.joblib')
print(f'train acc: {accuracy_score(y_train, clf.predict(X_train))}')
print(f'test acc: {accuracy_score(y_test, clf.predict(X_test))}') | code_generation | 609 | MIT | nlp_100_knocks | pythonを用いて、学習データから作成したロジスティック回帰モデルの正解率を、学習データおよび評価データ上で計測せよ。 |
|
import pandas as pd
import joblib
from sklearn.metrics import confusion_matrix
X_train = pd.read_table('ch06/train.feature.txt', header=None)
X_test = pd.read_table('ch06/test.feature.txt', header=None)
y_train = pd.read_table('ch06/train.txt', header=None)[1]
y_test = pd.read_table('ch06/test.txt', header=None)[1]
clf = joblib.load('ch06/model.joblib')
print(f'train confusion matrix:\n {confusion_matrix(y_train, clf.predict(X_train))}')
print(f'test confusion matrix:\n {confusion_matrix(y_test, clf.predict(X_test))}') | code_generation | 610 | MIT | nlp_100_knocks | pythonを用いて、学習データから作成したロジスティック回帰モデルの混同行列（confusion matrix）を、学習データおよび評価データ上で作成せよ。 |
|
import pandas as pd
import joblib
from sklearn.metrics import recall_score, precision_score, f1_score
X_train = pd.read_table('ch06/train.feature.txt', header=None)
X_test = pd.read_table('ch06/test.feature.txt', header=None)
y_train = pd.read_table('ch06/train.txt', header=None)[1]
y_test = pd.read_table('ch06/test.txt', header=None)[1]
clf = joblib.load('ch06/model.joblib')
y_pred = clf.predict(X_test)
print(f'test recall of None: {recall_score(y_test, y_pred, average=None)}')
print(f'test recall of micro: {recall_score(y_test, y_pred, average="micro")}')
print(f'test recall of macro: {recall_score(y_test, y_pred, average="macro")}')
print(f'test precision of None: {precision_score(y_test, y_pred, average=None)}')
print(f'test precision of micro: {precision_score(y_test, y_pred, average="micro")}')
print(f'test precision of macro: {precision_score(y_test, y_pred, average="macro")}')
print(f'test f1 of None: {f1_score(y_test, y_pred, average=None)}')
print(f'test f1 of micro: {f1_score(y_test, y_pred, average="micro")}')
print(f'test f1 of macro: {f1_score(y_test, y_pred, average="macro")}') | code_generation | 611 | MIT | nlp_100_knocks | pythonを用いて、学習データから作成したロジスティック回帰モデルの適合率、再現率、F1スコアを、評価データ上で計測せよ。カテゴリごとに適合率、再現率、F1スコアを求め、カテゴリごとの性能をマイクロ平均（micro-average）とマクロ平均（macro-average）で統合せよ。 |
|
import joblib
clf = joblib.load('ch06/model.joblib')
vocabulary_ = joblib.load('ch06/vocabulary_.joblib')
coefs = clf.coef_
for c in coefs:
d = dict(zip(vocabulary_, c))
d_top = sorted(d.items(), key=lambda x: abs(x[1]), reverse=True)[:10]
print(d_top)
d_bottom = sorted(d.items(), key=lambda x: abs(x[1]), reverse=False)[:10]
print(d_bottom) | code_generation | 612 | MIT | nlp_100_knocks | pythonを用いて、学習データから作成したロジスティック回帰モデルの中で、重みの高い特徴量トップ10と、重みの低い特徴量トップ10を確認せよ。 |
|
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
X_train = pd.read_table('ch06/train.feature.txt', header=None)
X_valid = pd.read_table('ch06/valid.feature.txt', header=None)
X_test = pd.read_table('ch06/test.feature.txt', header=None)
y_train = pd.read_table('ch06/train.txt', header=None)[1]
y_valid = pd.read_table('ch06/valid.txt', header=None)[1]
y_test = pd.read_table('ch06/test.txt', header=None)[1]
C_candidate = [0.1, 1.0, 10, 100]
train_acc = []
valid_acc = []
test_acc = []
for c in C_candidate:
clf = LogisticRegression(penalty='l2', solver='sag', random_state=0, C=c)
clf.fit(X_train, y_train)
train_acc.append(accuracy_score(y_train, clf.predict(X_train)))
valid_acc.append(accuracy_score(y_valid, clf.predict(X_valid)))
test_acc.append(accuracy_score(y_test, clf.predict(X_test)))
plt.plot(C_candidate, train_acc, label='train acc')
plt.plot(C_candidate, valid_acc, label='valid acc')
plt.plot(C_candidate, test_acc, label='test acc')
plt.legend()
plt.savefig('ch06/ans58.png') | code_generation | 613 | MIT | nlp_100_knocks | pythonを用いて、ロジスティック回帰モデルを学習するとき、正則化パラメータを調整することで、学習時の過学習（overfitting）の度合いを制御できる。異なる正則化パラメータでロジスティック回帰モデルを学習し、学習データ、検証データ、および評価データ上の正解率を求めよ。実験の結果は、正則化パラメータを横軸、正解率を縦軸としたグラフにまとめよ。 |
|
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
X_train = pd.read_table('ch06/train.feature.txt', header=None)
X_valid = pd.read_table('ch06/valid.feature.txt', header=None)
X_test = pd.read_table('ch06/test.feature.txt', header=None)
y_train = pd.read_table('ch06/train.txt', header=None)[1]
y_valid = pd.read_table('ch06/valid.txt', header=None)[1]
y_test = pd.read_table('ch06/test.txt', header=None)[1]
test_acc = []
C_candidate = [0.1, 1.0, 10, 100]
for c in C_candidate:
clf = LogisticRegression(penalty='l2', solver='sag', random_state=0, C=c)
clf.fit(X_train, y_train)
test_acc.append(accuracy_score(y_test, clf.predict(X_test)))
max_depth_candidate = [2, 4, 8, 16]
for m in max_depth_candidate:
clf = RandomForestClassifier(max_depth=m, random_state=0)
clf.fit(X_train, y_train)
test_acc.append(accuracy_score(y_test, clf.predict(X_test)))
bestIndex = test_acc.index(max(test_acc))
if bestIndex < 4:
bestAlg = 'LogisticRegression'
bestParam = f'C={C_candidate[bestIndex]}'
else:
bestAlg = 'RandomForestClassifier'
bestParam = f'max_depth={max_depth_candidate[bestIndex - 4]}'
print(bestAlg, bestParam) | code_generation | 614 | MIT | nlp_100_knocks | pythonを用いて、学習アルゴリズムや学習パラメータを変えながら、カテゴリ分類モデルを学習せよ。検証データ上の正解率が最も高くなる学習アルゴリズム・パラメータを求めよ。また、その学習アルゴリズム・パラメータを用いたときの評価データ上の正解率を求めよ。 |
|
from gensim.models import KeyedVectors
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
us = model['United_States']
print(us) | code_generation | 615 | MIT | nlp_100_knocks | pythonを用いて、Toggle menu
第7章: 単語ベクトル
On this page
60. 単語ベクトルの読み込みと表示
61. 単語の類似度
62. 類似度の高い単語10件
63. 加法構成性によるアナロジー
64. アナロジーデータでの実験
65. アナロジータスクでの正解率
66. WordSimilarity-353での評価
67. k-meansクラスタリング
68. Ward法によるクラスタリング
69. t-SNEによる可視化
単語の意味を実ベクトルで表現する単語ベクトル（単語埋め込み）に関して、以下の処理を行うプログラムを作成せよ。
60. 単語ベクトルの読み込みと表示Permalink
Google Newsデータセット（約1,000億単語）での学習済み単語ベクトル（300万単語・フレーズ、300次元）をダウンロードし、”United States”の単語ベクトルを表示せよ。ただし、”United States”は内部的には”United_States”と表現されていることに注意せよ。 |
|
import numpy as np
from gensim.models import KeyedVectors
def cosSim(v1, v2):
return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
us1 = model['United_States']
us2 = model['U.S.']
print(cosSim(us1, us2)) | code_generation | 616 | MIT | nlp_100_knocks | pythonを用いて、“United States”と”U.S.”のコサイン類似度を計算せよ。 |
|
from gensim.models import KeyedVectors
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
result = model.most_similar(positive=['United_States'])
for i in range(10):
print("{}: {:.4f}".format(*result[i])) | code_generation | 617 | MIT | nlp_100_knocks | pythonを用いて、“United States”とコサイン類似度が高い10語と、その類似度を出力せよ。 |
|
import numpy as np
from gensim.models import KeyedVectors
def cosSim(v1, v2):
return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
result = model.most_similar(positive=['Spain', 'Athens'], negative=['Madrid'])
for i in range(10):
print("{}: {:.4f}".format(*result[i])) | code_generation | 618 | MIT | nlp_100_knocks | pythonを用いて、“Spain”の単語ベクトルから”Madrid”のベクトルを引き、”Athens”のベクトルを足したベクトルを計算し、そのベクトルと類似度の高い10語とその類似度を出力せよ。 |
|
import pandas as pd
from gensim.models import KeyedVectors
from tqdm import tqdm
def culcSim(row):
global model
return pd.Series(list(model.most_similar(positive=[row['v2'], row['v3']], negative=[row['v1']])[0]))
tqdm.pandas()
df = pd.read_csv('ch07/questions-words.txt', sep=' ')
df = df.reset_index()
df.columns = ['v1', 'v2', 'v3', 'v4']
df.dropna(inplace=True)
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
df[['simWord', 'simScore']] = df.progress_apply(culcSim, axis=1)
df.to_csv('ch07/ans64.txt', sep=' ', index=False, header=None) | code_generation | 619 | MIT | nlp_100_knocks | pythonを用いて、単語アナロジーの評価データをダウンロードし、vec(2列目の単語) - vec(1列目の単語) + vec(3列目の単語)を計算し、そのベクトルと類似度が最も高い単語と、その類似度を求めよ。求めた単語と類似度は、各事例の末尾に追記せよ。 |
|
import pandas as pd
from gensim.models import KeyedVectors
from tqdm import tqdm
def culcSim(row):
global model
return pd.Series(list(model.most_similar(positive=[row['v2'], row['v3']], negative=[row['v1']])[0]))
tqdm.pandas()
df = pd.read_csv('ch07/questions-words.txt', sep=' ')
df = df.reset_index()
df.columns = ['v1', 'v2', 'v3', 'v4']
df.dropna(inplace=True)
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
df[['simWord', 'simScore']] = df.progress_apply(culcSim, axis=1)
df.to_csv('ch07/ans64.txt', sep=' ', index=False, header=None)
df = pd.read_csv('ch07/ans64.txt', sep=' ', header=None)
print((df[3] == df[4]).sum() / len(df)) | code_generation | 620 | MIT | nlp_100_knocks | pythonを用いて、単語アナロジーの評価データをダウンロードし、vec(2列目の単語) - vec(1列目の単語) + vec(3列目の単語)を計算し、そのベクトルと類似度が最も高い単語と、その類似度を求めよ。求めた単語と類似度は、各事例の末尾に追記し、この実行結果を用い、意味的アナロジー（semantic analogy）と文法的アナロジー（syntactic analogy）の正解率を測定せよ。 |
|
import pandas as pd
import numpy as np
from gensim.models import KeyedVectors
from tqdm import tqdm
def cosSim(v1, v2):
return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
def culcCosSim(row):
global model
w1v = model[row['Word 1']]
w2v = model[row['Word 2']]
return cosSim(w1v, w2v)
tqdm.pandas()
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
df = pd.read_csv('ch07/wordsim353/combined.csv')
df['cosSim'] = df.progress_apply(culcCosSim, axis=1)
print(df[['Human (mean)', 'cosSim']].corr(method='spearman')) | code_generation | 621 | MIT | nlp_100_knocks | pythonを用いて、The WordSimilarity-353 Test Collectionの評価データをダウンロードし、単語ベクトルにより計算される類似度のランキングと、人間の類似度判定のランキングの間のスピアマン相関係数を計算せよ。 |
|
import pandas as pd
import numpy as np
from gensim.models import KeyedVectors
from sklearn.cluster import KMeans
# http://www.fao.org/countryprofiles/iso3list/en/
country = pd.read_table('ch07/countries.tsv')
country = country['Short name'].values
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
countryVec = []
countryName = []
for c in country:
if c in model.vocab:
countryVec.append(model[c])
countryName.append(c)
X = np.array(countryVec)
km = KMeans(n_clusters=5, random_state=0)
y_km = km.fit_predict(X)
print(y_km) | code_generation | 622 | MIT | nlp_100_knocks | pythonを用いて、国名に関する単語ベクトルを抽出し、k-meansクラスタリングをクラスタ数k=5として実行せよ。 |
|
import pandas as pd
import numpy as np
from gensim.models import KeyedVectors
import matplotlib.pyplot as plt
from scipy.cluster.hierarchy import linkage, dendrogram
# http://www.fao.org/countryprofiles/iso3list/en/
country = pd.read_table('ch07/countries.tsv')
country = country['Short name'].values
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
countryVec = []
countryName = []
for c in country:
if c in model.vocab:
countryVec.append(model[c])
countryName.append(c)
X = np.array(countryVec)
linkage_result = linkage(X, method='ward', metric='euclidean')
plt.figure(num=None, figsize=(16, 9), dpi=200, facecolor='w', edgecolor='k')
dendrogram(linkage_result, labels=countryName)
plt.show() | code_generation | 623 | MIT | nlp_100_knocks | pythonを用いて、国名に関する単語ベクトルに対し、Ward法による階層型クラスタリングを実行せよ。さらに、クラスタリング結果をデンドログラムとして可視化せよ。 |
|
import pandas as pd
import numpy as np
from gensim.models import KeyedVectors
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
# http://www.fao.org/countryprofiles/iso3list/en/
country = pd.read_table('ch07/countries.tsv')
country = country['Short name'].values
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
countryVec = []
countryName = []
for c in country:
if c in model.vocab:
countryVec.append(model[c])
countryName.append(c)
X = np.array(countryVec)
tsne = TSNE(random_state=0, n_iter=15000, metric='cosine')
embs = tsne.fit_transform(X)
plt.scatter(embs[:, 0], embs[:, 1])
plt.show() | code_generation | 624 | MIT | nlp_100_knocks | pythonを用いて、ベクトル空間上の国名に関する単語ベクトルをt-SNEで可視化せよ。 |
|
import joblib
import numpy as np
import pandas as pd
from gensim.models import KeyedVectors
from tqdm import tqdm
def culcSwem(row):
global model
swem = [model[w] if w in model.vocab else np.zeros(shape=(model.vector_size,)) for w in row['TITLE'].split()]
swem = np.mean(np.array(swem), axis=0)
return swem
X_train = pd.read_table('ch06/train.txt', header=None)
X_valid = pd.read_table('ch06/valid.txt', header=None)
X_test = pd.read_table('ch06/test.txt', header=None)
use_cols = ['TITLE', 'CATEGORY']
n_train = len(X_train)
n_valid = len(X_valid)
n_test = len(X_test)
X_train.columns = use_cols
X_valid.columns = use_cols
X_test.columns = use_cols
data = pd.concat([X_train, X_valid, X_test]).reset_index(drop=True)
tqdm.pandas()
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
swemVec = data.progress_apply(culcSwem, axis=1)
X_train = np.array(list(swemVec.values)[:n_train])
X_valid = np.array(list(swemVec.values)[n_train:n_train + n_valid])
X_test = np.array(list(swemVec.values)[n_train + n_valid:])
joblib.dump(X_train, 'ch08/X_train.joblib')
joblib.dump(X_valid, 'ch08/X_valid.joblib')
joblib.dump(X_test, 'ch08/X_test.joblib')
y_data = data['CATEGORY'].map({'b': 0, 'e': 1, 't': 2, 'm': 3})
y_train = y_data.values[:n_train]
y_valid = y_data.values[n_train:n_train + n_valid]
y_test = y_data.values[n_train + n_valid:]
joblib.dump(y_train, 'ch08/y_train.joblib')
joblib.dump(y_valid, 'ch08/y_valid.joblib')
joblib.dump(y_test, 'ch08/y_test.joblib') | code_generation | 625 | MIT | nlp_100_knocks | pythonを用いて、手持ちの学習データ、検証データ、評価データを行列・ベクトルに変換したい。例えば、学習データについて、すべての事例$$x_i$$の特徴ベクトル$$\boldsymbol{x}_i$$を並べた行列$$X$$と、正解ラベルを並べた行列（ベクトル）$$Y$$を作成したい。
$$
X = \begin{pmatrix}
\boldsymbol{x}_1 \\
\boldsymbol{x}_2 \\
\dots \\
\boldsymbol{x}_n \\
\end{pmatrix} \in \mathbb{R}^{n \times d},
Y = \begin{pmatrix}
y_1 \\
y_2 \\
\dots \\
y_n \\
\end{pmatrix} \in \mathbb{N}^{n}
$$
ここで、$$n$$は学習データの事例数であり、$$\boldsymbol{x}_i \in \mathbb{R}^d$$と$$y_i \in \mathbb{N}$$はそれぞれ、$$i \in \{1, \dots, n\}$$番目の事例の特徴量ベクトルと正解ラベルを表す。
なお、今回は「ビジネス」「科学技術」「エンターテイメント」「健康」の4カテゴリ分類である。$$\mathbb{N}_{<4}$$で$$4$$未満の自然数（$$0$$を含む）を表すことにすれば、任意の事例の正解ラベル$$y_i$$は$$y_i \in \mathbb{N}_{<4}$$で表現できる。
以降では、ラベルの種類数を$$L$$で表す（今回の分類タスクでは$$L=4$$である）。
$$i$$番目の事例の特徴ベクトル$$\boldsymbol{x}_i$$は、次式で求める。
$$
\boldsymbol{x}_i = \frac{1}{T_i} \sum_{t=1}^{T_i} \mathrm{emb}(w_{i,t})
$$
ここで、$$i$$番目の事例は$$T_i$$個の（記事見出しの）単語列$$(w_{i,1}, w_{i,2}, \dots, w_{i,T_i})$$から構成され、$$\mathrm{emb}(w) \in \mathbb{R}^d$$は単語$$w$$に対応する単語ベクトル（次元数は$$d$$）である。すなわち、$$i$$番目の事例の記事見出しを、その見出しに含まれる単語のベクトルの平均で表現したものが$$\boldsymbol{x}_i$$である。今回は単語ベクトルとして、問題60でダウンロードしたものを用いればよい。$$300$$次元の単語ベクトルを用いたので、$$d=300$$である。
$$i$$番目の事例のラベル$$y_i$$は、次のように定義する。
$$
y_i = \begin{cases}
0 & (\mbox{記事}x_i\mbox{が「ビジネス」カテゴリの場合}) \\
1 & (\mbox{記事}x_i\mbox{が「科学技術」カテゴリの場合}) \\
2 & (\mbox{記事}x_i\mbox{が「エンターテイメント」カテゴリの場合}) \\
3 & (\mbox{記事}x_i\mbox{が「健康」カテゴリの場合}) \\
\end{cases}
$$
なお、カテゴリ名とラベルの番号が一対一で対応付いていれば、上式の通りの対応付けでなくてもよい。
以上の仕様に基づき、以下の行列・ベクトルを作成し、ファイルに保存せよ。
+ 学習データの特徴量行列: $$X_{\rm train} \in \mathbb{R}^{N_t \times d}$$
+ 学習データのラベルベクトル: $$Y_{\rm train} \in \mathbb{N}^{N_t}$$
+ 検証データの特徴量行列: $$X_{\rm valid} \in \mathbb{R}^{N_v \times d}$$
+ 検証データのラベルベクトル: $$Y_{\rm valid} \in \mathbb{N}^{N_v}$$
+ 評価データの特徴量行列: $$X_{\rm test} \in \mathbb{R}^{N_e \times d}$$
+ 評価データのラベルベクトル: $$Y_{\rm test} \in \mathbb{N}^{N_e}$$
なお、$$N_t, N_v, N_e$$はそれぞれ、学習データの事例数、検証データの事例数、評価データの事例数である。
ここで、nは学習データの事例数であり、xi∈Rdとyi∈Nはそれぞれ、i∈{1,…,n}番目の事例の特徴量ベクトルと正解ラベルを表す。 なお、今回は「ビジネス」「科学技術」「エンターテイメント」「健康」の4カテゴリ分類である。N<4で4未満の自然数（0を含む）を表すことにすれば、任意の事例の正解ラベルyiはyi∈N<4で表現できる。 以降では、ラベルの種類数をL
で表す（今回の分類タスクではL=4である）。
i番目の事例はTi個の（記事見出しの）単語列(wi,1,wi,2,…,wi,Ti)から構成され、emb(w)∈Rd
は単語wに対応する単語ベクトル（次元数はd）である。すなわち、i番目の事例の記事見出しを、その見出しに含まれる単語のベクトルの平均で表現したものがxiである。今回は単語ベクトルとして、問題60でダウンロードしたものを用いればよい。300次元の単語ベクトルを用いたので、d=300である。
i 番目の事例のラベルyiは、次のように定義する。
0(記事xiが「ビジネス」カテゴリの場合)
1(記事xiが「科学技術」カテゴリの場合)
2(記事xiが「エンターテイメント」カテゴリの場合)
3(記事xiが「健康」カテゴリの場合)
なお、カテゴリ名とラベルの番号が一対一で対応付いていれば、上式の通りの対応付けでなくてもよい。
以下の行列・ベクトルを作成し、ファイルに保存せよ。
学習データの特徴量行列、学習データのラベルベクトル、検証データの特徴量行列、検証データのラベルベクトル、評価データの特徴量行列、評価データのラベルベクトル
+ 学習データの特徴量行列: $$X_{\rm train} \in \mathbb{R}^{N_t \times d}$$
+ 学習データのラベルベクトル: $$Y_{\rm train} \in \mathbb{N}^{N_t}$$
+ 検証データの特徴量行列: $$X_{\rm valid} \in \mathbb{R}^{N_v \times d}$$
+ 検証データのラベルベクトル: $$Y_{\rm valid} \in \mathbb{N}^{N_v}$$
+ 評価データの特徴量行列: $$X_{\rm test} \in \mathbb{R}^{N_e \times d}$$
+ 評価データのラベルベクトル: $$Y_{\rm test} \in \mathbb{N}^{N_e}$$ |
|
import joblib
import numpy as np
import torch
import torch.nn as nn
X_train = joblib.load('ch08/X_train.joblib')
X_train = torch.from_numpy(X_train.astype(np.float32)).clone()
X = X_train[0:4]
net = nn.Sequential(nn.Linear(X.size()[1], 4), nn.Softmax(1))
y_pred = net(X)
print(y_pred) | code_generation | 626 | MIT | nlp_100_knocks | pythonを用いて、以下の行列を読み込み、学習データについて以下の計算を実行せよ。
$$
\hat{\boldsymbol{y}}_1 = {\rm softmax}(\boldsymbol{x}_1 W), \\
\hat{Y} = {\rm softmax}(X_{[1:4]} W)
$$
ただし、$${\rm softmax}$$はソフトマックス関数、$$X_{[1:4]} \in \mathbb{R}^{4 \times d}$$は特徴ベクトル$$\boldsymbol{x}_1, \boldsymbol{x}_2, \boldsymbol{x}_3, \boldsymbol{x}_4$$を縦に並べた行列である。
$$
X_{[1:4]} = \begin{pmatrix}
\boldsymbol{x}_1 \\
\boldsymbol{x}_2 \\
\boldsymbol{x}_3 \\
\boldsymbol{x}_4 \\
\end{pmatrix}
$$
行列$$W \in \mathbb{R}^{d \times L}$$は単層ニューラルネットワークの重み行列で、ここではランダムな値で初期化すればよい（問題73以降で学習して求める）。なお、$$\hat{\boldsymbol{y}}_1 \in \mathbb{R}^L$$は未学習の行列$$W$$で事例$$x_1$$を分類したときに、各カテゴリに属する確率を表すベクトルである。
同様に、$$\hat{Y} \in \mathbb{R}^{n \times L}$$は、学習データの事例$$x_1, x_2, x_3, x_4$$について、各カテゴリに属する確率を行列として表現している。
+ 学習データの特徴量行列: $$X_{\rm train} \in \mathbb{R}^{N_t \times d}$$
+ 学習データのラベルベクトル: $$Y_{\rm train} \in \mathbb{N}^{N_t}$$
+ 検証データの特徴量行列: $$X_{\rm valid} \in \mathbb{R}^{N_v \times d}$$
+ 検証データのラベルベクトル: $$Y_{\rm valid} \in \mathbb{N}^{N_v}$$
+ 評価データの特徴量行列: $$X_{\rm test} \in \mathbb{R}^{N_e \times d}$$
+ 評価データのラベルベクトル: $$Y_{\rm test} \in \mathbb{N}^{N_e}$$ |
|
import joblib
import numpy as np
import torch
import torch.nn as nn
X_train = joblib.load('ch08/X_train.joblib')
X_train = torch.from_numpy(X_train.astype(np.float32)).clone()
X = X_train[0:4]
net = nn.Sequential(nn.Linear(X.size()[1], 4), nn.Softmax(1))
y_pred = net(X)
print(y_pred) | code_generation | 627 | MIT | nlp_100_knocks | 学習データの事例$$x_1$$と事例集合$$x_1, x_2, x_3, x_4$$に対して、クロスエントロピー損失と、行列$$W$$に対する勾配を計算せよ。なお、ある事例$$x_i$$に対して損失は次式で計算される。
$$
l_i = - \log [\mbox{事例}x_i\mbox{が}y_i\mbox{に分類される確率}]
$$
ただし、事例集合に対するクロスエントロピー損失は、その集合に含まれる各事例の損失の平均とする。 |
|
import joblib
import numpy as np
import torch
from torch import nn, optim
X_train = joblib.load('ch08/X_train.joblib')
y_train = joblib.load('ch08/y_train.joblib')
X_train = torch.from_numpy(X_train.astype(np.float32)).clone()
y_train = torch.from_numpy(y_train.astype(np.int64)).clone()
X = X_train[0:4]
y = y_train[0:4]
net = nn.Linear(X.size()[1], 4)
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)
losses = []
for epoc in range(100):
optimizer.zero_grad()
y_pred = net(X)
loss = loss_fn(y_pred, y)
loss.backward()
optimizer.step()
losses.append(loss)
print(net.state_dict()['weight']) | code_generation | 628 | MIT | nlp_100_knocks | pythonを用いて、確率的勾配降下法（SGD: Stochastic Gradient Descent）を用いて、行列W
を学習せよ。なお、学習は適当な基準で終了させればよい（例えば「100エポックで終了」など）。 |
|
import joblib
import numpy as np
import torch
from torch import nn, optim
X_train = joblib.load('ch08/X_train.joblib')
y_train = joblib.load('ch08/y_train.joblib')
X_train = torch.from_numpy(X_train.astype(np.float32)).clone()
y_train = torch.from_numpy(y_train.astype(np.int64)).clone()
X_test = joblib.load('ch08/X_test.joblib')
y_test = joblib.load('ch08/y_test.joblib')
X_test = torch.from_numpy(X_test.astype(np.float32)).clone()
y_test = torch.from_numpy(y_test.astype(np.int64)).clone()
X = X_train[0:4]
y = y_train[0:4]
net = nn.Linear(X.size()[1], 4)
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)
losses = []
for epoc in range(100):
optimizer.zero_grad()
y_pred = net(X)
loss = loss_fn(y_pred, y)
loss.backward()
optimizer.step()
losses.append(loss)
_, y_pred_train = torch.max(net(X), 1)
print((y_pred_train == y).sum().item() / len(y))
_, y_pred_test = torch.max(net(X_test), 1)
print((y_pred_test == y_test).sum().item() / len(y_test)) | code_generation | 629 | MIT | nlp_100_knocks | pythonを用いて、確率的勾配降下法（SGD: Stochastic Gradient Descent）を用いて、行列W
を学習し、求めた行列を用いて学習データおよび評価データの事例を分類したとき、その正解率をそれぞれ求めよ。 |
|
import joblib
import numpy as np
import torch
from torch import nn, optim
import matplotlib.pyplot as plt
X_train = joblib.load('ch08/X_train.joblib')
y_train = joblib.load('ch08/y_train.joblib')
X_train = torch.from_numpy(X_train.astype(np.float32)).clone()
y_train = torch.from_numpy(y_train.astype(np.int64)).clone()
X_valid = joblib.load('ch08/X_valid.joblib')
y_valid = joblib.load('ch08/y_valid.joblib')
X_valid = torch.from_numpy(X_valid.astype(np.float32)).clone()
y_valid = torch.from_numpy(y_valid.astype(np.int64)).clone()
X_test = joblib.load('ch08/X_test.joblib')
y_test = joblib.load('ch08/y_test.joblib')
X_test = torch.from_numpy(X_test.astype(np.float32)).clone()
y_test = torch.from_numpy(y_test.astype(np.int64)).clone()
X = X_train[0:4]
y = y_train[0:4]
net = nn.Linear(X.size()[1], 4)
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)
train_losses = []
valid_losses = []
train_accs = []
valid_accs = []
for epoc in range(100):
optimizer.zero_grad()
y_pred = net(X)
loss = loss_fn(y_pred, y)
loss.backward()
optimizer.step()
train_losses.append(loss)
valid_losses.append(loss_fn(net(X_valid), y_valid))
_, y_pred_train = torch.max(net(X), 1)
train_accs.append((y_pred_train == y).sum().item() / len(y))
_, y_pred_valid = torch.max(net(X_valid), 1)
valid_accs.append((y_pred_valid == y_valid).sum().item() / len(y_valid))
plt.plot(train_losses, label='train loss')
plt.plot(valid_losses, label='valid loss')
plt.legend()
plt.show()
plt.plot(train_accs, label='train acc')
plt.plot(valid_accs, label='valid acc')
plt.legend()
plt.show() | code_generation | 630 | MIT | nlp_100_knocks | pythonを用いて、以下のコードを改変し、各エポックのパラメータ更新が完了するたびに、訓練データでの損失、正解率、検証データでの損失、正解率をグラフにプロットし、学習の進捗状況を確認できるようにせよ。
import joblib
import numpy as np
import torch
from torch import nn, optim
X_train = joblib.load('ch08/X_train.joblib')
y_train = joblib.load('ch08/y_train.joblib')
X_train = torch.from_numpy(X_train.astype(np.float32)).clone()
y_train = torch.from_numpy(y_train.astype(np.int64)).clone()
X = X_train[0:4]
y = y_train[0:4]
net = nn.Linear(X.size()[1], 4)
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)
losses = []
for epoc in range(100):
optimizer.zero_grad()
y_pred = net(X)
loss = loss_fn(y_pred, y)
loss.backward()
optimizer.step()
losses.append(loss)
print(net.state_dict()['weight']) |
|
import joblib
import numpy as np
import torch
from torch import nn, optim
import matplotlib.pyplot as plt
X_train = joblib.load('ch08/X_train.joblib')
y_train = joblib.load('ch08/y_train.joblib')
X_train = torch.from_numpy(X_train.astype(np.float32)).clone()
y_train = torch.from_numpy(y_train.astype(np.int64)).clone()
X_valid = joblib.load('ch08/X_valid.joblib')
y_valid = joblib.load('ch08/y_valid.joblib')
X_valid = torch.from_numpy(X_valid.astype(np.float32)).clone()
y_valid = torch.from_numpy(y_valid.astype(np.int64)).clone()
X_test = joblib.load('ch08/X_test.joblib')
y_test = joblib.load('ch08/y_test.joblib')
X_test = torch.from_numpy(X_test.astype(np.float32)).clone()
y_test = torch.from_numpy(y_test.astype(np.int64)).clone()
X = X_train[0:4]
y = y_train[0:4]
net = nn.Linear(X.size()[1], 4)
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)
train_losses = []
valid_losses = []
train_accs = []
valid_accs = []
for epoc in range(100):
optimizer.zero_grad()
y_pred = net(X)
loss = loss_fn(y_pred, y)
loss.backward()
optimizer.step()
joblib.dump(net.state_dict(), f'ch08/state_dict_{epoc}.joblib')
train_losses.append(loss)
valid_losses.append(loss_fn(net(X_valid), y_valid))
_, y_pred_train = torch.max(net(X), 1)
train_accs.append((y_pred_train == y).sum().item() / len(y))
_, y_pred_valid = torch.max(net(X_valid), 1)
valid_accs.append((y_pred_valid == y_valid).sum().item() / len(y_valid))
plt.plot(train_losses, label='train loss')
plt.plot(valid_losses, label='valid loss')
plt.legend()
plt.show()
plt.plot(train_accs, label='train acc')
plt.plot(valid_accs, label='valid acc')
plt.legend()
plt.show() | code_generation | 631 | MIT | nlp_100_knocks | pythonを用いて、以下のコードを改変し、各エポックのパラメータ更新が完了するたびに、チェックポイント（学習途中のパラメータ（重み行列など）の値や最適化アルゴリズムの内部状態）をファイルに書き出せ。
import joblib
import numpy as np
import torch
from torch import nn, optim
import matplotlib.pyplot as plt
X_train = joblib.load('ch08/X_train.joblib')
y_train = joblib.load('ch08/y_train.joblib')
X_train = torch.from_numpy(X_train.astype(np.float32)).clone()
y_train = torch.from_numpy(y_train.astype(np.int64)).clone()
X_valid = joblib.load('ch08/X_valid.joblib')
y_valid = joblib.load('ch08/y_valid.joblib')
X_valid = torch.from_numpy(X_valid.astype(np.float32)).clone()
y_valid = torch.from_numpy(y_valid.astype(np.int64)).clone()
X_test = joblib.load('ch08/X_test.joblib')
y_test = joblib.load('ch08/y_test.joblib')
X_test = torch.from_numpy(X_test.astype(np.float32)).clone()
y_test = torch.from_numpy(y_test.astype(np.int64)).clone()
X = X_train[0:4]
y = y_train[0:4]
net = nn.Linear(X.size()[1], 4)
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)
train_losses = []
valid_losses = []
train_accs = []
valid_accs = []
for epoc in range(100):
optimizer.zero_grad()
y_pred = net(X)
loss = loss_fn(y_pred, y)
loss.backward()
optimizer.step()
train_losses.append(loss)
valid_losses.append(loss_fn(net(X_valid), y_valid))
_, y_pred_train = torch.max(net(X), 1)
train_accs.append((y_pred_train == y).sum().item() / len(y))
_, y_pred_valid = torch.max(net(X_valid), 1)
valid_accs.append((y_pred_valid == y_valid).sum().item() / len(y_valid))
plt.plot(train_losses, label='train loss')
plt.plot(valid_losses, label='valid loss')
plt.legend()
plt.show()
plt.plot(train_accs, label='train acc')
plt.plot(valid_accs, label='valid acc')
plt.legend()
plt.show() |
|
import joblib
import numpy as np
from tqdm import tqdm
import torch
from torch.utils.data import TensorDataset, DataLoader
from torch import nn, optim
import matplotlib.pyplot as plt
X_train = joblib.load('ch08/X_train.joblib')
y_train = joblib.load('ch08/y_train.joblib')
X_train = torch.from_numpy(X_train.astype(np.float32)).clone()
y_train = torch.from_numpy(y_train.astype(np.int64)).clone()
X_valid = joblib.load('ch08/X_valid.joblib')
y_valid = joblib.load('ch08/y_valid.joblib')
X_valid = torch.from_numpy(X_valid.astype(np.float32)).clone()
y_valid = torch.from_numpy(y_valid.astype(np.int64)).clone()
X_test = joblib.load('ch08/X_test.joblib')
y_test = joblib.load('ch08/y_test.joblib')
X_test = torch.from_numpy(X_test.astype(np.float32)).clone()
y_test = torch.from_numpy(y_test.astype(np.int64)).clone()
X = X_train
y = y_train
ds = TensorDataset(X, y)
net = nn.Linear(X.size()[1], 4)
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)
batchSize = [1, 2, 4, 8]
for bs in batchSize:
loader = DataLoader(ds, batch_size=bs, shuffle=True)
train_losses = []
valid_losses = []
train_accs = []
valid_accs = []
for epoc in tqdm(range(100)):
train_running_loss = 0.0
valid_running_loss = 0.0
for xx, yy in loader:
y_pred = net(xx)
loss = loss_fn(y_pred, yy)
optimizer.zero_grad()
loss.backward()
optimizer.step()
train_running_loss += loss.item()
valid_running_loss += loss_fn(net(X_valid), y_valid).item()
joblib.dump(net.state_dict(), f'ch08/state_dict_{epoc}.joblib')
train_losses.append(train_running_loss)
valid_losses.append(valid_running_loss)
_, y_pred_train = torch.max(net(X), 1)
train_accs.append((y_pred_train == y).sum().item() / len(y))
_, y_pred_valid = torch.max(net(X_valid), 1)
valid_accs.append((y_pred_valid == y_valid).sum().item() / len(y_valid))
plt.plot(train_losses, label='train loss')
plt.plot(valid_losses, label='valid loss')
plt.legend()
plt.show()
plt.plot(train_accs, label='train acc')
plt.plot(valid_accs, label='valid acc')
plt.legend()
plt.show() | code_generation | 632 | MIT | nlp_100_knocks | pythonを用いて、以下のコードを改変し、B事例ごとに損失・勾配を計算し、行列Wの値を更新せよ（ミニバッチ化）。Bの値を1,2,4,8,…と変化させながら、1エポックの学習に要する時間を比較せよ。
import joblib
import numpy as np
import torch
from torch import nn, optim
import matplotlib.pyplot as plt
X_train = joblib.load('ch08/X_train.joblib')
y_train = joblib.load('ch08/y_train.joblib')
X_train = torch.from_numpy(X_train.astype(np.float32)).clone()
y_train = torch.from_numpy(y_train.astype(np.int64)).clone()
X_valid = joblib.load('ch08/X_valid.joblib')
y_valid = joblib.load('ch08/y_valid.joblib')
X_valid = torch.from_numpy(X_valid.astype(np.float32)).clone()
y_valid = torch.from_numpy(y_valid.astype(np.int64)).clone()
X_test = joblib.load('ch08/X_test.joblib')
y_test = joblib.load('ch08/y_test.joblib')
X_test = torch.from_numpy(X_test.astype(np.float32)).clone()
y_test = torch.from_numpy(y_test.astype(np.int64)).clone()
X = X_train[0:4]
y = y_train[0:4]
net = nn.Linear(X.size()[1], 4)
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)
train_losses = []
valid_losses = []
train_accs = []
valid_accs = []
for epoc in range(100):
optimizer.zero_grad()
y_pred = net(X)
loss = loss_fn(y_pred, y)
loss.backward()
optimizer.step()
joblib.dump(net.state_dict(), f'ch08/state_dict_{epoc}.joblib')
train_losses.append(loss)
valid_losses.append(loss_fn(net(X_valid), y_valid))
_, y_pred_train = torch.max(net(X), 1)
train_accs.append((y_pred_train == y).sum().item() / len(y))
_, y_pred_valid = torch.max(net(X_valid), 1)
valid_accs.append((y_pred_valid == y_valid).sum().item() / len(y_valid))
plt.plot(train_losses, label='train loss')
plt.plot(valid_losses, label='valid loss')
plt.legend()
plt.show()
plt.plot(train_accs, label='train acc')
plt.plot(valid_accs, label='valid acc')
plt.legend()
plt.show() |
|
import joblib
import numpy as np
from tqdm import tqdm
import torch
from torch.utils.data import TensorDataset, DataLoader
from torch import nn, optim
import matplotlib.pyplot as plt
X_train = joblib.load('ch08/X_train.joblib')
y_train = joblib.load('ch08/y_train.joblib')
X_train = torch.from_numpy(X_train.astype(np.float32)).clone()
y_train = torch.from_numpy(y_train.astype(np.int64)).clone()
X_valid = joblib.load('ch08/X_valid.joblib')
y_valid = joblib.load('ch08/y_valid.joblib')
X_valid = torch.from_numpy(X_valid.astype(np.float32)).clone()
y_valid = torch.from_numpy(y_valid.astype(np.int64)).clone()
X_test = joblib.load('ch08/X_test.joblib')
y_test = joblib.load('ch08/y_test.joblib')
X_test = torch.from_numpy(X_test.astype(np.float32)).clone()
y_test = torch.from_numpy(y_test.astype(np.int64)).clone()
X = X_train
y = y_train
X = X.to('cuda:0')
y = y.to('cuda:0')
ds = TensorDataset(X, y)
net = nn.Linear(X.size()[1], 4)
net = net.to('cuda:0')
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)
batchSize = [1, 2, 4, 8]
for bs in batchSize:
loader = DataLoader(ds, batch_size=bs, shuffle=True)
train_losses = []
valid_losses = []
train_accs = []
valid_accs = []
for epoc in tqdm(range(100)):
train_running_loss = 0.0
valid_running_loss = 0.0
for xx, yy in loader:
y_pred = net(xx)
loss = loss_fn(y_pred, yy)
optimizer.zero_grad()
loss.backward()
optimizer.step()
train_running_loss += loss.item()
valid_running_loss += loss_fn(net(X_valid), y_valid).item()
joblib.dump(net.state_dict(), f'ch08/state_dict_{epoc}.joblib')
train_losses.append(train_running_loss)
valid_losses.append(valid_running_loss)
_, y_pred_train = torch.max(net(X), 1)
train_accs.append((y_pred_train == y).sum().item() / len(y))
_, y_pred_valid = torch.max(net(X_valid), 1)
valid_accs.append((y_pred_valid == y_valid).sum().item() / len(y_valid))
plt.plot(train_losses, label='train loss')
plt.plot(valid_losses, label='valid loss')
plt.legend()
plt.show()
plt.plot(train_accs, label='train acc')
plt.plot(valid_accs, label='valid acc')
plt.legend()
plt.show() | code_generation | 633 | MIT | nlp_100_knocks | pythonを用いて、以下のコードを改変し、GPU上で学習を実行せよ。
import joblib
import numpy as np
from tqdm import tqdm
import torch
from torch.utils.data import TensorDataset, DataLoader
from torch import nn, optim
import matplotlib.pyplot as plt
X_train = joblib.load('ch08/X_train.joblib')
y_train = joblib.load('ch08/y_train.joblib')
X_train = torch.from_numpy(X_train.astype(np.float32)).clone()
y_train = torch.from_numpy(y_train.astype(np.int64)).clone()
X_valid = joblib.load('ch08/X_valid.joblib')
y_valid = joblib.load('ch08/y_valid.joblib')
X_valid = torch.from_numpy(X_valid.astype(np.float32)).clone()
y_valid = torch.from_numpy(y_valid.astype(np.int64)).clone()
X_test = joblib.load('ch08/X_test.joblib')
y_test = joblib.load('ch08/y_test.joblib')
X_test = torch.from_numpy(X_test.astype(np.float32)).clone()
y_test = torch.from_numpy(y_test.astype(np.int64)).clone()
X = X_train
y = y_train
ds = TensorDataset(X, y)
net = nn.Linear(X.size()[1], 4)
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)
batchSize = [1, 2, 4, 8]
for bs in batchSize:
loader = DataLoader(ds, batch_size=bs, shuffle=True)
train_losses = []
valid_losses = []
train_accs = []
valid_accs = []
for epoc in tqdm(range(100)):
train_running_loss = 0.0
valid_running_loss = 0.0
for xx, yy in loader:
y_pred = net(xx)
loss = loss_fn(y_pred, yy)
optimizer.zero_grad()
loss.backward()
optimizer.step()
train_running_loss += loss.item()
valid_running_loss += loss_fn(net(X_valid), y_valid).item()
joblib.dump(net.state_dict(), f'ch08/state_dict_{epoc}.joblib')
train_losses.append(train_running_loss)
valid_losses.append(valid_running_loss)
_, y_pred_train = torch.max(net(X), 1)
train_accs.append((y_pred_train == y).sum().item() / len(y))
_, y_pred_valid = torch.max(net(X_valid), 1)
valid_accs.append((y_pred_valid == y_valid).sum().item() / len(y_valid))
plt.plot(train_losses, label='train loss')
plt.plot(valid_losses, label='valid loss')
plt.legend()
plt.show()
plt.plot(train_accs, label='train acc')
plt.plot(valid_accs, label='valid acc')
plt.legend()
plt.show() |
|
import joblib
import numpy as np
from tqdm import tqdm
import torch
from torch.utils.data import TensorDataset, DataLoader
from torch import nn, optim
import matplotlib.pyplot as plt
X_train = joblib.load('ch08/X_train.joblib')
y_train = joblib.load('ch08/y_train.joblib')
X_train = torch.from_numpy(X_train.astype(np.float32)).clone()
y_train = torch.from_numpy(y_train.astype(np.int64)).clone()
X_valid = joblib.load('ch08/X_valid.joblib')
y_valid = joblib.load('ch08/y_valid.joblib')
X_valid = torch.from_numpy(X_valid.astype(np.float32)).clone()
y_valid = torch.from_numpy(y_valid.astype(np.int64)).clone()
X_test = joblib.load('ch08/X_test.joblib')
y_test = joblib.load('ch08/y_test.joblib')
X_test = torch.from_numpy(X_test.astype(np.float32)).clone()
y_test = torch.from_numpy(y_test.astype(np.int64)).clone()
X = X_train
y = y_train
X = X.to('cuda:0')
y = y.to('cuda:0')
ds = TensorDataset(X, y)
net = nn.Sequential(
nn.Linear(X.size()[1], 100),
nn.PReLU(),
nn.BatchNorm1d(100),
nn.Linear(100, 25),
nn.PReLU(),
nn.BatchNorm1d(25),
nn.Linear(25, 4)
)
net = net.to('cuda:0')
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)
batchSize = [64]
for bs in batchSize:
loader = DataLoader(ds, batch_size=bs, shuffle=True)
train_losses = []
valid_losses = []
train_accs = []
valid_accs = []
for epoc in tqdm(range(100)):
train_running_loss = 0.0
valid_running_loss = 0.0
for xx, yy in loader:
y_pred = net(xx)
loss = loss_fn(y_pred, yy)
optimizer.zero_grad()
loss.backward()
optimizer.step()
train_running_loss += loss.item()
valid_running_loss += loss_fn(net(X_valid), y_valid).item()
joblib.dump(net.state_dict(), f'ch08/state_dict_{epoc}.joblib')
train_losses.append(train_running_loss)
valid_losses.append(valid_running_loss)
_, y_pred_train = torch.max(net(X), 1)
train_accs.append((y_pred_train == y).sum().item() / len(y))
_, y_pred_valid = torch.max(net(X_valid), 1)
valid_accs.append((y_pred_valid == y_valid).sum().item() / len(y_valid))
plt.plot(train_losses, label='train loss')
plt.plot(valid_losses, label='valid loss')
plt.legend()
plt.show()
plt.plot(train_accs, label='train acc')
plt.plot(valid_accs, label='valid acc')
plt.legend()
plt.show() | code_generation | 634 | MIT | nlp_100_knocks | pythonを用いて、以下のコードを改変し、バイアス項の導入や多層化など、ニューラルネットワークの形状を変更しながら、高性能なカテゴリ分類器を構築せよ。
import joblib
import numpy as np
from tqdm import tqdm
import torch
from torch.utils.data import TensorDataset, DataLoader
from torch import nn, optim
import matplotlib.pyplot as plt
X_train = joblib.load('ch08/X_train.joblib')
y_train = joblib.load('ch08/y_train.joblib')
X_train = torch.from_numpy(X_train.astype(np.float32)).clone()
y_train = torch.from_numpy(y_train.astype(np.int64)).clone()
X_valid = joblib.load('ch08/X_valid.joblib')
y_valid = joblib.load('ch08/y_valid.joblib')
X_valid = torch.from_numpy(X_valid.astype(np.float32)).clone()
y_valid = torch.from_numpy(y_valid.astype(np.int64)).clone()
X_test = joblib.load('ch08/X_test.joblib')
y_test = joblib.load('ch08/y_test.joblib')
X_test = torch.from_numpy(X_test.astype(np.float32)).clone()
y_test = torch.from_numpy(y_test.astype(np.int64)).clone()
X = X_train
y = y_train
X = X.to('cuda:0')
y = y.to('cuda:0')
ds = TensorDataset(X, y)
net = nn.Linear(X.size()[1], 4)
net = net.to('cuda:0')
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.01)
batchSize = [1, 2, 4, 8]
for bs in batchSize:
loader = DataLoader(ds, batch_size=bs, shuffle=True)
train_losses = []
valid_losses = []
train_accs = []
valid_accs = []
for epoc in tqdm(range(100)):
train_running_loss = 0.0
valid_running_loss = 0.0
for xx, yy in loader:
y_pred = net(xx)
loss = loss_fn(y_pred, yy)
optimizer.zero_grad()
loss.backward()
optimizer.step()
train_running_loss += loss.item()
valid_running_loss += loss_fn(net(X_valid), y_valid).item()
joblib.dump(net.state_dict(), f'ch08/state_dict_{epoc}.joblib')
train_losses.append(train_running_loss)
valid_losses.append(valid_running_loss)
_, y_pred_train = torch.max(net(X), 1)
train_accs.append((y_pred_train == y).sum().item() / len(y))
_, y_pred_valid = torch.max(net(X_valid), 1)
valid_accs.append((y_pred_valid == y_valid).sum().item() / len(y_valid))
plt.plot(train_losses, label='train loss')
plt.plot(valid_losses, label='valid loss')
plt.legend()
plt.show()
plt.plot(train_accs, label='train acc')
plt.plot(valid_accs, label='valid acc')
plt.legend()
plt.show() |
|
from torchtext import data
TEXT = data.Field(sequential=True, lower=True, batch_first=True)
LABELS = data.Field(sequential=False, batch_first=True, use_vocab=False)
train, valid, test = data.TabularDataset.splits(
path='ch06', train='train2.txt',
validation='valid2.txt', test='test2.txt', format='tsv',
fields=[('text', TEXT), ('labels', LABELS)])
TEXT.build_vocab(train, min_freq=2)
print(TEXT.vocab.stoi) | code_generation | 635 | MIT | nlp_100_knocks | pythonを用いて、手持ちの学習データ中の単語にユニークなID番号を付与したい。学習データ中で最も頻出する単語に`1`、2番目に頻出する単語に`2`、……といった方法で、学習データ中で2回以上出現する単語にID番号を付与せよ。そして、与えられた単語列に対して、ID番号の列を返す関数を実装せよ。ただし、出現頻度が2回未満の単語のID番号はすべて`0`とせよ。 |
|
from torchtext import data
import torch
from torch import nn
class RNN(nn.Module):
def __init__(self, num_embeddings,
embedding_dim=50,
hidden_size=50,
output_size=1,
num_layers=1,
dropout=0.2):
super().__init__()
self.emb = nn.Embedding(num_embeddings, embedding_dim,
padding_idx=0)
self.lstm = nn.LSTM(embedding_dim,
hidden_size, num_layers,
batch_first=True, dropout=dropout)
self.linear = nn.Linear(hidden_size, output_size)
def forward(self, x, h0=None):
x = self.emb(x)
x, h = self.lstm(x, h0)
x = x[:, -1, :]
x = self.linear(x)
return x
TEXT = data.Field(sequential=True, lower=True, batch_first=True)
LABELS = data.Field(sequential=False, batch_first=True, use_vocab=False)
train, val, test = data.TabularDataset.splits(
path='ch06', train='train2.txt',
validation='valid2.txt', test='test2.txt', format='tsv',
fields=[('TEXT', TEXT), ('LABEL', LABELS)])
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
train_iter, val_iter, test_iter = data.Iterator.splits(
(train, val, test), batch_sizes=(64, 64, 64), device=device, repeat=False, sort=False)
TEXT.build_vocab(train, min_freq=2)
LABELS.build_vocab(train)
model = RNN(len(TEXT.vocab.stoi) + 1, num_layers=2, output_size=4)
for epoch in range(1):
model.train()
for batch in train_iter:
x, y = batch.TEXT, batch.LABEL
y_pred = model(x)
print(y_pred)
print(y_pred.shape) | code_generation | 636 | MIT | nlp_100_knocks | pythonを用いて、ID番号で表現された単語列$$\boldsymbol{x} = (x_1, x_2, \dots, x_T)$$がある。ただし、$$T$$は単語列の長さ、$$x_t \in \mathbb{R}^{V}$$は単語のID番号のone-hot表記である（$$V$$は単語の総数である）。再帰型ニューラルネットワーク（RNN: Recurrent Neural Network）を用い、単語列$$\boldsymbol{x}$$からカテゴリ$$y$$を予測するモデルとして、次式を実装せよ。
$$
\overrightarrow{h}_0 = 0, \\
\overrightarrow{h}_t = {\rm \overrightarrow{RNN}}(\mathrm{emb}(x_t), \overrightarrow{h}_{t-1}), \\
y = {\rm softmax}(W^{(yh)} \overrightarrow{h}_T + b^{(y)})
$$
ただし、$$\mathrm{emb}(x) \in \mathbb{R}^{d_w}$$は単語埋め込み（単語のone-hot表記から単語ベクトルに変換する関数）、$$\overrightarrow{h}_t \in \mathbb{R}^{d_h}$$は時刻$$t$$の隠れ状態ベクトル、$${\rm \overrightarrow{RNN}}(x,h)$$は入力$$x$$と前時刻の隠れ状態$$h$$から次状態を計算するRNNユニット、$$W^{(yh)} \in \mathbb{R}^{L \times d_h}$$は隠れ状態ベクトルからカテゴリを予測するための行列、$$b^{(y)} \in \mathbb{R}^{L}$$はバイアス項である（$$d_w, d_h, L$$はそれぞれ、単語埋め込みの次元数、隠れ状態ベクトルの次元数、ラベル数である）。RNNユニット$${\rm \overrightarrow{RNN}}(x,h)$$には様々な構成が考えられるが、典型例として次式が挙げられる。
$$
{\rm \overrightarrow{RNN}}(x,h) = g(W^{(hx)} x + W^{(hh)}h + b^{(h)})
$$
ただし、$$W^{(hx)} \in \mathbb{R}^{d_h \times d_w}、W^{(hh)} \in \mathbb{R}^{d_h \times d_h}, b^{(h)} \in \mathbb{R}^{d_h}$$はRNNユニットのパラメータ、$$g$$は活性化関数（例えば$$\tanh$$やReLUなど）である。
なお、この問題ではパラメータの学習を行わず、ランダムに初期化されたパラメータで$$y$$を計算するだけでよい。次元数などのハイパーパラメータは、$$d_w = 300, d_h=50$$など、適当な値に設定せよ（以降の問題でも同様である）。 |
|
import torch
from torch import nn, optim
from torchtext import data
from catalyst.dl import SupervisedRunner
from catalyst.dl.callbacks import AccuracyCallback
from torch.utils.data import DataLoader
from torchtext.data import Iterator
class BucketIteratorWrapper(DataLoader):
__initialized__ = False
def __init__(self, iterator: Iterator):
self.batch_size = iterator.batch_size
self.num_workers = 1
self.collate_fn = None
self.pin_memory = False
self.drop_last = False
self.timeout = 0
self.worker_init_fn = None
self.sampler = iterator
self.batch_sampler = iterator
self.__initialized__ = True
def __iter__(self):
return map(lambda batch: {
'features': batch.TEXT,
'targets': batch.LABEL,
}, self.batch_sampler.__iter__())
def __len__(self):
return len(self.batch_sampler)
class RNN(nn.Module):
def __init__(self, num_embeddings,
embedding_dim=50,
hidden_size=50,
output_size=1,
num_layers=1,
dropout=0.2):
super().__init__()
self.emb = nn.Embedding(num_embeddings, embedding_dim,
padding_idx=0)
self.lstm = nn.LSTM(embedding_dim,
hidden_size, num_layers,
batch_first=True, dropout=dropout)
self.linear = nn.Linear(hidden_size, output_size)
def forward(self, x, h0=None):
x = self.emb(x)
x, h = self.lstm(x, h0)
x = x[:, -1, :]
x = self.linear(x)
return x
TEXT = data.Field(sequential=True, lower=True, batch_first=True)
LABELS = data.Field(sequential=False, batch_first=True, use_vocab=False)
train, val, test = data.TabularDataset.splits(
path='ch06', train='train2.txt',
validation='valid2.txt', test='test2.txt', format='tsv',
fields=[('TEXT', TEXT), ('LABEL', LABELS)])
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
train_iter, val_iter, test_iter = data.BucketIterator.splits(
(train, val, test), batch_sizes=(len(train), len(val), len(test)), device=device, repeat=False, sort=False)
train_loader = BucketIteratorWrapper(train_iter)
valid_loader = BucketIteratorWrapper(val_iter)
loaders = {"train": train_loader, "valid": valid_loader}
TEXT.build_vocab(train, min_freq=2)
LABELS.build_vocab(train)
model = RNN(len(TEXT.vocab.stoi) + 1, num_layers=2, output_size=4)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
runner = SupervisedRunner()
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
loaders=loaders,
logdir="./logdir",
callbacks=[AccuracyCallback(num_classes=4, accuracy_args=[1])],
num_epochs=10,
verbose=True,
) | code_generation | 637 | MIT | nlp_100_knocks | pythonを用いて、確率的勾配降下法（SGD: Stochastic Gradient Descent）を用いて、問題81で構築したモデルを学習せよ。訓練データ上の損失と正解率、評価データ上の損失と正解率を表示しながらモデルを学習し、適当な基準（例えば10エポックなど）で終了させよ。 |
|
import torch
from torch import nn, optim
from torchtext import data
from catalyst.dl import SupervisedRunner
from catalyst.dl.callbacks import AccuracyCallback
from torch.utils.data import DataLoader
from torchtext.data import Iterator
class BucketIteratorWrapper(DataLoader):
__initialized__ = False
def __init__(self, iterator: Iterator):
self.batch_size = iterator.batch_size
self.num_workers = 1
self.collate_fn = None
self.pin_memory = False
self.drop_last = False
self.timeout = 0
self.worker_init_fn = None
self.sampler = iterator
self.batch_sampler = iterator
self.__initialized__ = True
def __iter__(self):
return map(lambda batch: {
'features': batch.TEXT,
'targets': batch.LABEL,
}, self.batch_sampler.__iter__())
def __len__(self):
return len(self.batch_sampler)
class RNN(nn.Module):
def __init__(self, num_embeddings,
embedding_dim=50,
hidden_size=50,
output_size=1,
num_layers=1,
dropout=0.2):
super().__init__()
self.emb = nn.Embedding(num_embeddings, embedding_dim,
padding_idx=0)
self.lstm = nn.LSTM(embedding_dim,
hidden_size, num_layers,
batch_first=True, dropout=dropout)
self.linear = nn.Linear(hidden_size, output_size)
def forward(self, x, h0=None):
x = self.emb(x)
x, h = self.lstm(x, h0)
x = x[:, -1, :]
x = self.linear(x)
return x
TEXT = data.Field(sequential=True, lower=True, batch_first=True)
LABELS = data.Field(sequential=False, batch_first=True, use_vocab=False)
train, val, test = data.TabularDataset.splits(
path='ch06', train='train2.txt',
validation='valid2.txt', test='test2.txt', format='tsv',
fields=[('TEXT', TEXT), ('LABEL', LABELS)])
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
train_iter, val_iter, test_iter = data.BucketIterator.splits(
(train, val, test), batch_sizes=(64, 64, 64), device=device, repeat=False, sort=False)
train_loader = BucketIteratorWrapper(train_iter)
valid_loader = BucketIteratorWrapper(val_iter)
loaders = {"train": train_loader, "valid": valid_loader}
TEXT.build_vocab(train, min_freq=2)
LABELS.build_vocab(train)
model = RNN(len(TEXT.vocab.stoi) + 1, num_layers=2, output_size=4)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
runner = SupervisedRunner()
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
loaders=loaders,
logdir="./logdir",
callbacks=[AccuracyCallback(num_classes=4, accuracy_args=[1])],
num_epochs=10,
verbose=True,
) | code_generation | 638 | MIT | nlp_100_knocks | pythonを用いて、以下のコードを改変し、$$B$$事例ごとに損失・勾配を計算して学習を行えるようにせよ（$$B$$の値は適当に選べ）。また、GPU上で学習を実行せよ。
import torch
from torch import nn, optim
from torchtext import data
from catalyst.dl import SupervisedRunner
from catalyst.dl.callbacks import AccuracyCallback
from torch.utils.data import DataLoader
from torchtext.data import Iterator
class BucketIteratorWrapper(DataLoader):
__initialized__ = False
def __init__(self, iterator: Iterator):
self.batch_size = iterator.batch_size
self.num_workers = 1
self.collate_fn = None
self.pin_memory = False
self.drop_last = False
self.timeout = 0
self.worker_init_fn = None
self.sampler = iterator
self.batch_sampler = iterator
self.__initialized__ = True
def __iter__(self):
return map(lambda batch: {
'features': batch.TEXT,
'targets': batch.LABEL,
}, self.batch_sampler.__iter__())
def __len__(self):
return len(self.batch_sampler)
class RNN(nn.Module):
def __init__(self, num_embeddings,
embedding_dim=50,
hidden_size=50,
output_size=1,
num_layers=1,
dropout=0.2):
super().__init__()
self.emb = nn.Embedding(num_embeddings, embedding_dim,
padding_idx=0)
self.lstm = nn.LSTM(embedding_dim,
hidden_size, num_layers,
batch_first=True, dropout=dropout)
self.linear = nn.Linear(hidden_size, output_size)
def forward(self, x, h0=None):
x = self.emb(x)
x, h = self.lstm(x, h0)
x = x[:, -1, :]
x = self.linear(x)
return x
TEXT = data.Field(sequential=True, lower=True, batch_first=True)
LABELS = data.Field(sequential=False, batch_first=True, use_vocab=False)
train, val, test = data.TabularDataset.splits(
path='ch06', train='train2.txt',
validation='valid2.txt', test='test2.txt', format='tsv',
fields=[('TEXT', TEXT), ('LABEL', LABELS)])
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
train_iter, val_iter, test_iter = data.BucketIterator.splits(
(train, val, test), batch_sizes=(len(train), len(val), len(test)), device=device, repeat=False, sort=False)
train_loader = BucketIteratorWrapper(train_iter)
valid_loader = BucketIteratorWrapper(val_iter)
loaders = {"train": train_loader, "valid": valid_loader}
TEXT.build_vocab(train, min_freq=2)
LABELS.build_vocab(train)
model = RNN(len(TEXT.vocab.stoi) + 1, num_layers=2, output_size=4)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
runner = SupervisedRunner()
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
loaders=loaders,
logdir="./logdir",
callbacks=[AccuracyCallback(num_classes=4, accuracy_args=[1])],
num_epochs=10,
verbose=True,
) |
|
import torch
from torch import nn, optim
from torchtext import data
from catalyst.dl import SupervisedRunner
from catalyst.dl.callbacks import AccuracyCallback
from torch.utils.data import DataLoader
from torchtext.data import Iterator
from gensim.models import KeyedVectors
class BucketIteratorWrapper(DataLoader):
__initialized__ = False
def __init__(self, iterator: Iterator):
self.batch_size = iterator.batch_size
self.num_workers = 1
self.collate_fn = None
self.pin_memory = False
self.drop_last = False
self.timeout = 0
self.worker_init_fn = None
self.sampler = iterator
self.batch_sampler = iterator
self.__initialized__ = True
def __iter__(self):
return map(lambda batch: {
'features': batch.TEXT,
'targets': batch.LABEL,
}, self.batch_sampler.__iter__())
def __len__(self):
return len(self.batch_sampler)
class RNN(nn.Module):
def __init__(self, num_embeddings,
embedding_dim=300,
hidden_size=300,
output_size=1,
num_layers=1,
dropout=0.2):
super().__init__()
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
weights = torch.FloatTensor(model.vectors)
self.emb = nn.Embedding.from_pretrained(weights)
self.lstm = nn.LSTM(embedding_dim,
hidden_size, num_layers,
batch_first=True, dropout=dropout)
self.linear = nn.Linear(hidden_size, output_size)
def forward(self, x, h0=None):
x = self.emb(x)
x, h = self.lstm(x, h0)
x = x[:, -1, :]
x = self.linear(x)
return x
TEXT = data.Field(sequential=True, lower=True, batch_first=True)
LABELS = data.Field(sequential=False, batch_first=True, use_vocab=False)
train, val, test = data.TabularDataset.splits(
path='ch06', train='train2.txt',
validation='valid2.txt', test='test2.txt', format='tsv',
fields=[('TEXT', TEXT), ('LABEL', LABELS)])
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
train_iter, val_iter, test_iter = data.BucketIterator.splits(
(train, val, test), batch_sizes=(64, 64, 64), device=device, repeat=False, sort=False)
train_loader = BucketIteratorWrapper(train_iter)
valid_loader = BucketIteratorWrapper(val_iter)
loaders = {"train": train_loader, "valid": valid_loader}
TEXT.build_vocab(train, min_freq=2)
LABELS.build_vocab(train)
model = RNN(len(TEXT.vocab.stoi) + 1, num_layers=2, output_size=4)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
runner = SupervisedRunner()
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
loaders=loaders,
logdir="./logdir",
callbacks=[AccuracyCallback(num_classes=4, accuracy_args=[1])],
num_epochs=10,
verbose=True,
) | code_generation | 639 | MIT | nlp_100_knocks | pythonを用いて、事前学習済みの単語ベクトル（例えば、Google Newsデータセット（約1,000億単語）での[学習済み単語ベクトル](https://drive.google.com/file/d/0B7XkCwpI5KDYNlNUTTlSS21pQmM/edit?usp=sharing)）で単語埋め込み$$\mathrm{emb}(x)$$を初期化し、学習せよ。 |
|
import torch
from torch import nn, optim
from torchtext import data
from catalyst.dl import SupervisedRunner
from catalyst.dl.callbacks import AccuracyCallback
from torch.utils.data import DataLoader
from torchtext.data import Iterator
from gensim.models import KeyedVectors
class BucketIteratorWrapper(DataLoader):
__initialized__ = False
def __init__(self, iterator: Iterator):
self.batch_size = iterator.batch_size
self.num_workers = 1
self.collate_fn = None
self.pin_memory = False
self.drop_last = False
self.timeout = 0
self.worker_init_fn = None
self.sampler = iterator
self.batch_sampler = iterator
self.__initialized__ = True
def __iter__(self):
return map(lambda batch: {
'features': batch.TEXT,
'targets': batch.LABEL,
}, self.batch_sampler.__iter__())
def __len__(self):
return len(self.batch_sampler)
class RNN(nn.Module):
def __init__(self, num_embeddings,
embedding_dim=300,
hidden_size=300,
output_size=1,
num_layers=1,
dropout=0.2):
super().__init__()
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
weights = torch.FloatTensor(model.vectors)
self.emb = nn.Embedding.from_pretrained(weights)
self.lstm = nn.LSTM(embedding_dim,
hidden_size, num_layers,
batch_first=True, dropout=dropout, bidirectional=True)
self.linear = nn.Linear(hidden_size * 2, output_size)
def forward(self, x, h0=None):
x = self.emb(x)
x, h = self.lstm(x, h0)
x = x[:, -1, :]
x = self.linear(x)
return x
TEXT = data.Field(sequential=True, lower=True, batch_first=True)
LABELS = data.Field(sequential=False, batch_first=True, use_vocab=False)
train, val, test = data.TabularDataset.splits(
path='ch06', train='train2.txt',
validation='valid2.txt', test='test2.txt', format='tsv',
fields=[('TEXT', TEXT), ('LABEL', LABELS)])
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
train_iter, val_iter, test_iter = data.BucketIterator.splits(
(train, val, test), batch_sizes=(64, 64, 64), device=device, repeat=False, sort=False)
train_loader = BucketIteratorWrapper(train_iter)
valid_loader = BucketIteratorWrapper(val_iter)
loaders = {"train": train_loader, "valid": valid_loader}
TEXT.build_vocab(train, min_freq=2)
LABELS.build_vocab(train)
model = RNN(len(TEXT.vocab.stoi) + 1, num_layers=2, output_size=4)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
runner = SupervisedRunner()
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
loaders=loaders,
logdir="./logdir",
callbacks=[AccuracyCallback(num_classes=4, accuracy_args=[1])],
num_epochs=10,
verbose=True,
) | code_generation | 640 | MIT | nlp_100_knocks | pythonを用いて、順方向と逆方向のRNNの両方を用いて入力テキストをエンコードし、モデルを学習せよ。
$$
\overleftarrow{h}_{T+1} = 0, \\
\overleftarrow{h}_t = {\rm \overleftarrow{RNN}}(\mathrm{emb}(x_t), \overleftarrow{h}_{t+1}), \\
y = {\rm softmax}(W^{(yh)} [\overrightarrow{h}_T; \overleftarrow{h}_1] + b^{(y)})
$$
ただし、$$\overrightarrow{h}_t \in \mathbb{R}^{d_h}, \overleftarrow{h}_t \in \mathbb{R}^{d_h}$$はそれぞれ、順方向および逆方向のRNNで求めた時刻$$t$$の隠れ状態ベクトル、$${\rm \overleftarrow{RNN}}(x,h)$$は入力$$x$$と次時刻の隠れ状態$$h$$から前状態を計算するRNNユニット、$$W^{(yh)} \in \mathbb{R}^{L \times 2d_h}$$は隠れ状態ベクトルからカテゴリを予測するための行列、$$b^{(y)} \in \mathbb{R}^{L}$$はバイアス項である。また、$$[a; b]$$はベクトル$$a$$と$$b$$の連結を表す。
さらに、双方向RNNを多層化して実験せよ。 |
|
import torch
from torch import nn, optim
import torch.nn.functional as F
from torchtext import data
from torch.utils.data import DataLoader
from torchtext.data import Iterator
from gensim.models import KeyedVectors
class BucketIteratorWrapper(DataLoader):
__initialized__ = False
def __init__(self, iterator: Iterator):
self.batch_size = iterator.batch_size
self.num_workers = 1
self.collate_fn = None
self.pin_memory = False
self.drop_last = False
self.timeout = 0
self.worker_init_fn = None
self.sampler = iterator
self.batch_sampler = iterator
self.__initialized__ = True
def __iter__(self):
return map(lambda batch: {
'features': batch.TEXT,
'targets': batch.LABEL,
}, self.batch_sampler.__iter__())
def __len__(self):
return len(self.batch_sampler)
class CNN(nn.Module):
def __init__(self, output_dim, kernel_num, kernel_sizes=[3, 4, 5], dropout=0.5, static=False):
super(CNN, self).__init__()
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
weights = torch.FloatTensor(model.vectors)
self.embed = nn.Embedding.from_pretrained(weights)
self.convs1 = nn.ModuleList([nn.Conv2d(1, kernel_num, (k, self.embed.weight.shape[1])) for k in kernel_sizes])
self.dropout = nn.Dropout(dropout)
self.fc1 = nn.Linear(len(kernel_sizes) * kernel_num, output_dim)
self.static = static
def conv_and_pool(self, x, conv):
x = F.relu(conv(x)).squeeze(3)
x = F.max_pool1d(x, x.size(2)).squeeze(2)
return x
def forward(self, x):
x = self.embed(x)
if self.static:
x = x.detach()
x = x.unsqueeze(1)
x = x.float()
x = [F.relu(conv(x)).squeeze(3) for conv in self.convs1]
x = [F.max_pool1d(i, i.size(2)).squeeze(2) for i in x]
x = torch.cat(x, 1)
x = self.dropout(x)
logit = self.fc1(x)
return logit
TEXT = data.Field(sequential=True, lower=True, batch_first=True)
LABELS = data.Field(sequential=False, batch_first=True, use_vocab=False)
train, val, test = data.TabularDataset.splits(
path='ch06', train='train2.txt',
validation='valid2.txt', test='test2.txt', format='tsv',
fields=[('TEXT', TEXT), ('LABEL', LABELS)])
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
train_iter, val_iter, test_iter = data.BucketIterator.splits(
(train, val, test), batch_sizes=(64, 64, 64), device=device, repeat=False, sort=False)
train_loader = BucketIteratorWrapper(train_iter)
valid_loader = BucketIteratorWrapper(val_iter)
loaders = {"train": train_loader, "valid": valid_loader}
TEXT.build_vocab(train, min_freq=2)
LABELS.build_vocab(train)
model = CNN(output_dim=4, kernel_num=3, kernel_sizes=[3, 4, 5], dropout=0.2)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
for epoch in range(1):
model.train()
for batch in train_iter:
x, y = batch.TEXT, batch.LABEL
y_pred = model(x)
print(y_pred)
print(y_pred.shape) | code_generation | 641 | MIT | nlp_100_knocks | pythonを用いて、ID番号で表現された単語列$$\boldsymbol{x} = (x_1, x_2, \dots, x_T)$$がある。ただし、$$T$$は単語列の長さ、$$x_t \in \mathbb{R}^{V}$$は単語のID番号のone-hot表記である（$$V$$は単語の総数である）。畳み込みニューラルネットワーク（CNN: Convolutional Neural Network）を用い、単語列$$\boldsymbol{x}$$からカテゴリ$$y$$を予測するモデルを実装せよ。
ただし、畳み込みニューラルネットワークの構成は以下の通りとする。
+ 単語埋め込みの次元数: $$d_w$$
+ 畳み込みのフィルターのサイズ: 3 トークン
+ 畳み込みのストライド: 1 トークン
+ 畳み込みのパディング: あり
+ 畳み込み演算後の各時刻のベクトルの次元数: $$d_h$$
+ 畳み込み演算後に最大値プーリング（max pooling）を適用し、入力文を$$d_h$$次元の隠れベクトルで表現
すなわち、時刻$$t$$の特徴ベクトル$$p_t \in \mathbb{R}^{d_h}$$は次式で表される。
$$
p_t = g(W^{(px)} [\mathrm{emb}(x_{t-1}); \mathrm{emb}(x_t); \mathrm{emb}(x_{t+1})] + b^{(p)})
$$
ただし、$$W^{(px)} \in \mathbb{R}^{d_h \times 3d_w}, b^{(p)} \in \mathbb{R}^{d_h}$$はCNNのパラメータ、$$g$$は活性化関数（例えば$$\tanh$$やReLUなど）、$$[a; b; c]$$はベクトル$$a, b, c$$の連結である。なお、行列$$W^{(px)}$$の列数が$$3d_w$$になるのは、3個のトークンの単語埋め込みを連結したものに対して、線形変換を行うためである。
最大値プーリングでは、特徴ベクトルの次元毎に全時刻における最大値を取り、入力文書の特徴ベクトル$$c \in \mathbb{R}^{d_h}$$を求める。$$c[i]$$でベクトル$$c$$の$$i$$番目の次元の値を表すことにすると、最大値プーリングは次式で表される。
$$
c[i] = \max_{1 \leq t \leq T} p_t[i]
$$
最後に、入力文書の特徴ベクトル$$c$$に行列$$W^{(yc)} \in \mathbb{R}^{L \times d_h}$$とバイアス項$$b^{(y)} \in \mathbb{R}^{L}$$による線形変換とソフトマックス関数を適用し、カテゴリ$$y$$を予測する。
$$
y = {\rm softmax}(W^{(yc)} c + b^{(y)})
$$
なお、この問題ではモデルの学習を行わず、ランダムに初期化された重み行列で$$y$$を計算するだけでよい。 |
|
import torch
from torch import nn, optim
import torch.nn.functional as F
from torchtext import data
from catalyst.dl import SupervisedRunner
from catalyst.dl.callbacks import AccuracyCallback
from torch.utils.data import DataLoader
from torchtext.data import Iterator
from gensim.models import KeyedVectors
class BucketIteratorWrapper(DataLoader):
__initialized__ = False
def __init__(self, iterator: Iterator):
self.batch_size = iterator.batch_size
self.num_workers = 1
self.collate_fn = None
self.pin_memory = False
self.drop_last = False
self.timeout = 0
self.worker_init_fn = None
self.sampler = iterator
self.batch_sampler = iterator
self.__initialized__ = True
def __iter__(self):
return map(lambda batch: {
'features': batch.TEXT,
'targets': batch.LABEL,
}, self.batch_sampler.__iter__())
def __len__(self):
return len(self.batch_sampler)
class CNN(nn.Module):
def __init__(self, output_dim, kernel_num, kernel_sizes=[3, 4, 5], dropout=0.5, static=False):
super(CNN, self).__init__()
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
weights = torch.FloatTensor(model.vectors)
self.embed = nn.Embedding.from_pretrained(weights)
self.convs1 = nn.ModuleList([nn.Conv2d(1, kernel_num, (k, self.embed.weight.shape[1])) for k in kernel_sizes])
self.dropout = nn.Dropout(dropout)
self.fc1 = nn.Linear(len(kernel_sizes) * kernel_num, output_dim)
self.static = static
def conv_and_pool(self, x, conv):
x = F.relu(conv(x)).squeeze(3)
x = F.max_pool1d(x, x.size(2)).squeeze(2)
return x
def forward(self, x):
x = self.embed(x)
if self.static:
x = x.detach()
x = x.unsqueeze(1)
x = x.float()
x = [F.relu(conv(x)).squeeze(3) for conv in self.convs1]
x = [F.max_pool1d(i, i.size(2)).squeeze(2) for i in x]
x = torch.cat(x, 1)
x = self.dropout(x)
logit = self.fc1(x)
return logit
TEXT = data.Field(sequential=True, lower=True, batch_first=True)
LABELS = data.Field(sequential=False, batch_first=True, use_vocab=False)
train, val, test = data.TabularDataset.splits(
path='ch06', train='train2.txt',
validation='valid2.txt', test='test2.txt', format='tsv',
fields=[('TEXT', TEXT), ('LABEL', LABELS)])
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
train_iter, val_iter, test_iter = data.BucketIterator.splits(
(train, val, test), batch_sizes=(64, 64, 64), device=device, repeat=False, sort=False)
train_loader = BucketIteratorWrapper(train_iter)
valid_loader = BucketIteratorWrapper(val_iter)
loaders = {"train": train_loader, "valid": valid_loader}
TEXT.build_vocab(train, min_freq=2)
LABELS.build_vocab(train)
model = CNN(output_dim=4, kernel_num=3, kernel_sizes=[3, 4, 5], dropout=0.2)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
runner = SupervisedRunner()
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
loaders=loaders,
logdir="./logdir",
callbacks=[AccuracyCallback(num_classes=4, accuracy_args=[1])],
num_epochs=10,
verbose=True,
) | code_generation | 642 | MIT | nlp_100_knocks | pythonを用いて、確率的勾配降下法（SGD: Stochastic Gradient Descent）を用いて、問題86で構築したモデルを学習せよ。訓練データ上の損失と正解率、評価データ上の損失と正解率を表示しながらモデルを学習し、適当な基準（例えば10エポックなど）で終了させよ。 |
|
import torch
from torch import nn, optim
from torchtext import data
from catalyst.dl import SupervisedRunner
from catalyst.dl.callbacks import AccuracyCallback
from torch.utils.data import DataLoader
from torchtext.data import Iterator
from gensim.models import KeyedVectors
class BucketIteratorWrapper(DataLoader):
__initialized__ = False
def __init__(self, iterator: Iterator):
self.batch_size = iterator.batch_size
self.num_workers = 1
self.collate_fn = None
self.pin_memory = False
self.drop_last = False
self.timeout = 0
self.worker_init_fn = None
self.sampler = iterator
self.batch_sampler = iterator
self.__initialized__ = True
def __iter__(self):
return map(lambda batch: {
'features': batch.TEXT,
'targets': batch.LABEL,
}, self.batch_sampler.__iter__())
def __len__(self):
return len(self.batch_sampler)
class RNN(nn.Module):
def __init__(self, num_embeddings,
embedding_dim=300,
hidden_size=300,
output_size=1,
num_layers=1,
dropout=0.2):
super().__init__()
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
weights = torch.FloatTensor(model.vectors)
self.emb = nn.Embedding.from_pretrained(weights)
self.lstm = nn.LSTM(embedding_dim,
hidden_size, num_layers,
batch_first=True, dropout=dropout, bidirectional=True)
self.linear = nn.Sequential(
nn.Linear(hidden_size * 2, 100),
nn.PReLU(),
nn.BatchNorm1d(100),
nn.Linear(100, output_size)
)
def forward(self, x, h0=None):
x = self.emb(x)
x, h = self.lstm(x, h0)
x = x[:, -1, :]
x = self.linear(x)
return x
TEXT = data.Field(sequential=True, lower=True, batch_first=True)
LABELS = data.Field(sequential=False, batch_first=True, use_vocab=False)
train, val, test = data.TabularDataset.splits(
path='ch06', train='train2.txt',
validation='valid2.txt', test='test2.txt', format='tsv',
fields=[('TEXT', TEXT), ('LABEL', LABELS)])
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
train_iter, val_iter, test_iter = data.BucketIterator.splits(
(train, val, test), batch_sizes=(64, 64, 64), device=device, repeat=False, sort=False)
train_loader = BucketIteratorWrapper(train_iter)
valid_loader = BucketIteratorWrapper(val_iter)
loaders = {"train": train_loader, "valid": valid_loader}
TEXT.build_vocab(train, min_freq=2)
LABELS.build_vocab(train)
model = RNN(len(TEXT.vocab.stoi) + 1, num_layers=2, output_size=4)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
runner = SupervisedRunner()
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
loaders=loaders,
logdir="./logdir",
callbacks=[AccuracyCallback(num_classes=4, accuracy_args=[1])],
num_epochs=10,
verbose=True,
) | code_generation | 643 | MIT | nlp_100_knocks | pythonを用いて、以下のコードを改変し、ニューラルネットワークの形状やハイパーパラメータを調整しながら、高性能なカテゴリ分類器を構築せよ。
import torch
from torch import nn, optim
import torch.nn.functional as F
from torchtext import data
from catalyst.dl import SupervisedRunner
from catalyst.dl.callbacks import AccuracyCallback
from torch.utils.data import DataLoader
from torchtext.data import Iterator
from gensim.models import KeyedVectors
class BucketIteratorWrapper(DataLoader):
__initialized__ = False
def __init__(self, iterator: Iterator):
self.batch_size = iterator.batch_size
self.num_workers = 1
self.collate_fn = None
self.pin_memory = False
self.drop_last = False
self.timeout = 0
self.worker_init_fn = None
self.sampler = iterator
self.batch_sampler = iterator
self.__initialized__ = True
def __iter__(self):
return map(lambda batch: {
'features': batch.TEXT,
'targets': batch.LABEL,
}, self.batch_sampler.__iter__())
def __len__(self):
return len(self.batch_sampler)
class CNN(nn.Module):
def __init__(self, output_dim, kernel_num, kernel_sizes=[3, 4, 5], dropout=0.5, static=False):
super(CNN, self).__init__()
model = KeyedVectors.load_word2vec_format('ch07/GoogleNews-vectors-negative300.bin', binary=True)
weights = torch.FloatTensor(model.vectors)
self.embed = nn.Embedding.from_pretrained(weights)
self.convs1 = nn.ModuleList([nn.Conv2d(1, kernel_num, (k, self.embed.weight.shape[1])) for k in kernel_sizes])
self.dropout = nn.Dropout(dropout)
self.fc1 = nn.Linear(len(kernel_sizes) * kernel_num, output_dim)
self.static = static
def conv_and_pool(self, x, conv):
x = F.relu(conv(x)).squeeze(3)
x = F.max_pool1d(x, x.size(2)).squeeze(2)
return x
def forward(self, x):
x = self.embed(x)
if self.static:
x = x.detach()
x = x.unsqueeze(1)
x = x.float()
x = [F.relu(conv(x)).squeeze(3) for conv in self.convs1]
x = [F.max_pool1d(i, i.size(2)).squeeze(2) for i in x]
x = torch.cat(x, 1)
x = self.dropout(x)
logit = self.fc1(x)
return logit
TEXT = data.Field(sequential=True, lower=True, batch_first=True)
LABELS = data.Field(sequential=False, batch_first=True, use_vocab=False)
train, val, test = data.TabularDataset.splits(
path='ch06', train='train2.txt',
validation='valid2.txt', test='test2.txt', format='tsv',
fields=[('TEXT', TEXT), ('LABEL', LABELS)])
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
train_iter, val_iter, test_iter = data.BucketIterator.splits(
(train, val, test), batch_sizes=(64, 64, 64), device=device, repeat=False, sort=False)
train_loader = BucketIteratorWrapper(train_iter)
valid_loader = BucketIteratorWrapper(val_iter)
loaders = {"train": train_loader, "valid": valid_loader}
TEXT.build_vocab(train, min_freq=2)
LABELS.build_vocab(train)
model = CNN(output_dim=4, kernel_num=3, kernel_sizes=[3, 4, 5], dropout=0.2)
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
runner = SupervisedRunner()
runner.train(
model=model,
criterion=criterion,
optimizer=optimizer,
loaders=loaders,
logdir="./logdir",
callbacks=[AccuracyCallback(num_classes=4, accuracy_args=[1])],
num_epochs=10,
verbose=True,
) |
|
from tqdm import tqdm
import torch
from torch import optim
from torchtext import data
from transformers import BertForSequenceClassification
def eval_net(model, data_loader, device='cpu'):
model.eval()
ys = []
ypreds = []
for x, y, _ in data_loader:
with torch.no_grad():
loss, logit = model(input_ids=x, labels=y)
_, y_pred = torch.max(logit, 1)
ys.append(y)
ypreds.append(y_pred)
ys = torch.cat(ys)
ypreds = torch.cat(ypreds)
print(f'test acc: {(ys == ypreds).sum().item() / len(ys)}')
return
TEXT = data.Field(sequential=True, lower=True, batch_first=True)
LABELS = data.Field(sequential=False, batch_first=True, use_vocab=False)
train, val, test = data.TabularDataset.splits(
path='ch06', train='train2.txt',
validation='valid2.txt', test='test2.txt', format='tsv',
fields=[('TEXT', TEXT), ('LABEL', LABELS)])
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
train_iter, val_iter, test_iter = data.Iterator.splits(
(train, val, test), batch_sizes=(64, 64, 64), device=device, repeat=False, sort=False)
TEXT.build_vocab(train, min_freq=2)
LABELS.build_vocab(train)
model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=4)
model = model.to(device)
optimizer = optim.SGD(model.parameters(), lr=0.01)
for epoch in tqdm(range(10)):
losses = []
model.train()
for batch in train_iter:
x, y = batch.TEXT, batch.LABEL
loss, logit = model(input_ids=x, labels=y)
model.zero_grad()
loss.backward()
optimizer.step()
losses.append(loss.item())
_, y_pred_train = torch.max(logit, 1)
eval_net(model, test_iter, device) | code_generation | 644 | MIT | nlp_100_knocks | pythonを用いて、事前学習済み言語モデル（例えば[BERT](https://github.com/google-research/bert)など）を出発点として、ニュース記事見出しをカテゴリに分類するモデルを構築せよ。 |
|
onmt_preprocess -train_src data/kyoto-train.ja -train_tgt data/kyoto-train.en -valid_src data/kyoto-dev.ja -valid_tgt data/kyoto-dev.en -save_data data/data -src_vocab_size 10000 -tgt_vocab_size 10000
onmt_train \
-data data/data \
-save_model data/demo-model \
-train_steps 100000 \
-world_size 1 \
-gpu_ranks 0 | code_generation | 645 | MIT | nlp_100_knocks | shellscriptを用いて、機械翻訳のデータセットをダウンロードせよ。訓練データ、開発データ、評価データを整形し、必要に応じてトークン化などの前処理を行うこと。ただし、この段階ではトークンの単位として形態素（日本語）および単語（英語）を採用せよ。 |
|
onmt_translate \
-model data/demo-model_step_100000.pt \
-src data/kyoto-test.ja \
-output pred.txt \
-replace_unk \
-verbose \
-gpu 0 | code_generation | 646 | MIT | nlp_100_knocks | shellscriptを用いて、手持ちのデータを用いて、ニューラル機械翻訳のモデルを学習せよ（ニューラルネットワークのモデルはTransformerやLSTMなど適当に選んでよい）。 |
|
# https://forum.opennmt.net/t/simple-opennmt-py-rest-server/1392
export IP="0.0.0.0"
export PORT=5000
export URL_ROOT="/translator"
export CONFIG="./available_models/conf.json"
export HOST="127.0.0.1"
# NOTE that these parameters are optionnal
# here, we explicitely set to default values
python server.py --ip $IP --port $PORT --url_root $URL_ROOT --config $CONFIG
# curl http://$HOST:$PORT$URL_ROOT/models
# curl -i -X POST -H "Content-Type: application/json" \
# -d '[{"src": "本日 は 晴天 なり", "id": 100}]' \
# http://$HOST:$PORT$URL_ROOT/translate | perl -Xpne 's/\\u([0-9a-fA-F]{4})/chr(hex($1))/eg' | code_generation | 647 | MIT | nlp_100_knocks | shellscriptを用いて、ニューラル機械翻訳モデルを用い、与えられた（任意の）日本語の文を英語に翻訳するプログラムを実装せよ。 |
|
def max1(m,n):
if m>n:
return m
else:
return n | code_generation | 1,048 | MIT | python_for_begginers_solve_50_exercises | pythonを用いて、引数として2つの数値を取り、その中で最大の数値を返す関数max()を定義してなさい。なお、Pythonで利用可能なif-then-else構文を使用すること。 |
|
def max_of_three(a,b,c):
if a>b and a>c:
print a
elif b>c:
print b
else:
print c | code_generation | 1,049 | MIT | python_for_begginers_solve_50_exercises | pythonを用いて、引数として3つの数値を取り、その中で最大の値を返す関数max_of_three()を定義しなさい。 |
|
def length(x):
c=0
for _ in a:
c = c +1
return c | code_generation | 1,050 | MIT | python_for_begginers_solve_50_exercises | pythonを用いて、与えられたリスト、もしくは文字列の長さを計算する関数を定義しなさい。 |
|
def vowel(x):
if x in ('aeiou'):
return True
else:
return False | code_generation | 1,051 | MIT | python_for_begginers_solve_50_exercises | pythonを用いて、長さ1の文字列（すなわち文字）を受け取り、それが母音であればTrueを、そうでなければFalseを返す関数を書きなさい。 |
|
def translate(x):
s = ''
for i in x:
if i not in ('aeiou'):
s += i + "o" + i
else:
s += i
print s | code_generation | 1,052 | MIT | python_for_begginers_solve_50_exercises | pythonを用いて、テキストを "rövarspråket"（スウェーデン語で "強盗語"）に翻訳する関数translate()を書いてください。このとき、すべての子音を二重にして、その間に "o "を入れるようにして下さい。例えば、translate("this is fun")は "totohisos isos fofunon "という文字列を返すはずです。 |
|
def sum1(x):
c=0
for i in x:
c += i
return c
print sum1([1, 2, 3, 4])
def multiply(x):
c=1
for i in x:
c *= i
return c | code_generation | 1,053 | MIT | python_for_begginers_solve_50_exercises | pythonを用いて、関数sum()と関数multiply()を定義して下さい。例えば、sum([1, 2, 3, 4])
は10を返し、multiply([1, 2, 3, 4]) は24を返します。 |
|
def reverse(x):
new =[]
for i in range(len(x))[::-1]:
new.append(x[i])
print ''.join(new) | code_generation | 1,054 | MIT | python_for_begginers_solve_50_exercises | pythonを用いて、文字列の反転を計算する関数reverse()を定義しなさい。例えば、reverse("I am testing")は "gnitset ma I "という文字列を返します。 |