input
stringlengths 0
929
| output
stringlengths 0
10.3k
| task
stringclasses 3
values | index
int64 0
5.38k
| liscence
stringclasses 4
values | source
stringclasses 15
values | instruction
stringlengths 13
3.45k
|
|---|---|---|---|---|---|---|
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を用いて、ニューラル機械翻訳モデルを用い、与えられた（任意の）日本語の文を英語に翻訳するプログラムを実装せよ。 |
|
import numpy as np | code_generation | 648 | The Unliscence | 100_numpy_exercises | numpyパッケージを "np" という名前でインポートしなさい。 |
|
print(np.__version__)
np.show_config() | code_generation | 649 | The Unliscence | 100_numpy_exercises | numpyのバージョンと設定を表示しなさい。 |
|
Z = np.zeros(10)
print(Z) | code_generation | 650 | The Unliscence | 100_numpy_exercises | numpyを用いて、サイズ10の空行列を作成しなさい。 |
|
print("%d bytes" % (Z.size * Z.itemsize)) | code_generation | 651 | The Unliscence | 100_numpy_exercises | numpyを用いて、次に示す配列のメモリサイズを調べなさい。
Z = np.zeros((10,10)) |
|
%run `python -c "import numpy; numpy.info(numpy.add)"` | code_generation | 652 | The Unliscence | 100_numpy_exercises | コマンドラインからnumpy add関数のドキュメントを取得しなさい。 |
|
Z = np.zeros(10)
Z[4] = 1
print(Z) | code_generation | 653 | The Unliscence | 100_numpy_exercises | numpyを用いて、サイズ10の空行列を作成しなさい。ただし、5番目の値は1である。 |
|
Z = np.arange(10,50)
print(Z) | code_generation | 654 | The Unliscence | 100_numpy_exercises | numpyを用いて、10から49までの値を持つベクトルを作成しなさい。 |
|
Z = Z[::-1]
print(Z) | code_generation | 655 | The Unliscence | 100_numpy_exercises | numpyを用いて、次に示すベクトルを逆にしなさい（最初の要素が最後の要素になる）。
Z = np.arange(50) |
|
Z = np.arange(9).reshape(3, 3)
print(Z) | code_generation | 656 | The Unliscence | 100_numpy_exercises | numpyを用いて、0から8までの値を持つ3x3の行列を作成する。 |
|
nz = np.nonzero([1,2,0,0,4,0])
print(nz) | code_generation | 657 | The Unliscence | 100_numpy_exercises | numpyを用いて、[1,2,0,0,4,0]から非ゼロ要素のインデックスを見つけなさい。 |
|
Z = np.eye(3)
print(Z) | code_generation | 658 | The Unliscence | 100_numpy_exercises | numpyを用いて、3x3の恒等行列を作りなさい。 |
|
Z = np.random.random((3,3,3))
print(Z) | code_generation | 659 | The Unliscence | 100_numpy_exercises | numpyを用いて、ランダムな値で3x3x3の配列を作成しなさい。 |
|
Z = np.random.random((10,10))
Zmin, Zmax = Z.min(), Z.max()
print(Zmin, Zmax) | code_generation | 660 | The Unliscence | 100_numpy_exercises | numpyを用いて、ランダムな値で10x10の配列を作成し、最小値と最大値を求めなさい。 |
|
Z = np.random.random(30)
m = Z.mean()
print(m) | code_generation | 661 | The Unliscence | 100_numpy_exercises | numpyを用いて、サイズ30のランダムなベクトルを作成し、平均値を求めなさい。 |
|
Z = np.ones((10,10))
Z[1:-1,1:-1] = 0
print(Z) | code_generation | 662 | The Unliscence | 100_numpy_exercises | numpyを用いて、境界線上に1、内側に0を持つ2次元配列を作成しなさい。 |
|
Z = np.ones((5,5))
Z = np.pad(Z, pad_width=1, mode='constant', constant_values=0)
print(Z)
# Using fancy indexing
Z[:, [0, -1]] = 0
Z[[0, -1], :] = 0
print(Z) | code_generation | 663 | The Unliscence | 100_numpy_exercises | numpyを用いて、既存の配列の周囲にボーダー（0で塗りつぶされたもの）を追加しなさい。 |
|
print(0 * np.nan)
print(np.nan == np.nan)
print(np.inf > np.nan)
print(np.nan - np.nan)
print(np.nan in set([np.nan]))
print(0.3 == 3 * 0.1) | code_generation | 664 | The Unliscence | 100_numpy_exercises | 次の6つの式の結果を表示して下さい。
0 * np.nan
np.nan == np.nan
np.inf > np.nan
np.nan - np.nan
np.nan in set([np.nan])
0.3 == 3 * 0.1 |
|
Z = np.diag(1+np.arange(4),k=-1)
print(Z) | code_generation | 665 | The Unliscence | 100_numpy_exercises | numpyを用いて、対角線のすぐ下に値1,2,3,4を持つ5x5の行列を作成しなさい。 |
|
Z = np.zeros((8,8),dtype=int)
Z[1::2,::2] = 1
Z[::2,1::2] = 1
print(Z) | code_generation | 666 | The Unliscence | 100_numpy_exercises | numpyを用いて、8x8のマトリックスを作成し、市松模様で塗りつぶしなさい。 |
|
print(np.unravel_index(99,(6,7,8))) | code_generation | 667 | The Unliscence | 100_numpy_exercises | numpyを用いて、(6,7,8)型の配列を考えよう。100番目の要素のインデックス(x,y,z)は？ |
|
Z = np.tile( np.array([[0,1],[1,0]]), (4,4))
print(Z) | code_generation | 668 | The Unliscence | 100_numpy_exercises | numpyのtile関数を用いて、8x8のチェッカーボード行列を作りなさい。 |
|
Z = np.random.random((5,5))
Z = (Z - np.mean (Z)) / (np.std (Z))
print(Z) | code_generation | 669 | The Unliscence | 100_numpy_exercises | numpyを用いて、5x5のランダム行列を正規化しなさい。 |
|
color = np.dtype([("r", np.ubyte),
("g", np.ubyte),
("b", np.ubyte),
("a", np.ubyte)]) | code_generation | 670 | The Unliscence | 100_numpy_exercises | numpyを用いて、色を4つの符号なしバイト(RGBA)として記述するカスタムd型を作成しなさい。 |
|
Z = np.dot(np.ones((5,3)), np.ones((3,2)))
print(Z)
# Alternative solution, in Python 3.5 and above
Z = np.ones((5,3)) @ np.ones((3,2))
print(Z) | code_generation | 671 | The Unliscence | 100_numpy_exercises | numpyを用いて、5x3の行列と3x2の行列の乗算をしなさい。 |
|
Z = np.arange(11)
Z[(3 < Z) & (Z < 8)] *= -1
print(Z) | code_generation | 672 | The Unliscence | 100_numpy_exercises | numpyを用いて、1次元の配列が与えられたとき、3から8までの要素をすべて無効にしなさい。 |
|
print(sum(range(5),-1))
from numpy import *
print(sum(range(5),-1)) | code_generation | 673 | The Unliscence | 100_numpy_exercises | 次のスクリプトの出力は？
print(sum(range(5),-1))
from numpy import *
print(sum(range(5),-1)) |
|
Z**Z
2 << Z >> 2
Z <- Z
1j*Z
Z/1/1
Z<Z>Z | code_generation | 674 | The Unliscence | 100_numpy_exercises | numpyを用いて、整数ベクトルZを考えてみよう。 |
|
print(np.array(0) / np.array(0))
print(np.array(0) // np.array(0))
print(np.array([np.nan]).astype(int).astype(float)) | code_generation | 675 | The Unliscence | 100_numpy_exercises | 次の式の結果を表示しなさい。
np.array(0) / np.array(0)
np.array(0) // np.array(0)
np.array([np.nan]).astype(int).astype(float) |
|
Z = np.random.uniform(-10,+10,10)
print(np.copysign(np.ceil(np.abs(Z)), Z))
# More readable but less efficient
print(np.where(Z>0, np.ceil(Z), np.floor(Z))) | code_generation | 676 | The Unliscence | 100_numpy_exercises | numpyを用いて、浮動小数点数の配列をゼロから切り捨てなさい。
Z = np.random.uniform(-10,+10,10) |
|
Z1 = np.random.randint(0,10,10)
Z2 = np.random.randint(0,10,10)
print(np.intersect1d(Z1,Z2)) | code_generation | 677 | The Unliscence | 100_numpy_exercises | numpyを用いて、2つの配列間の共通値を見つけなさい。
Z1 = np.random.randint(0,10,10)
Z2 = np.random.randint(0,10,10) |
|
# Suicide mode on
defaults = np.seterr(all="ignore")
Z = np.ones(1) / 0
# Back to sanity
_ = np.seterr(**defaults)
# Equivalently with a context manager
with np.errstate(all="ignore"):
np.arange(3) / 0 | code_generation | 678 | The Unliscence | 100_numpy_exercises | numpyの警告をすべて無視するには？ |
|
False | code_generation | 679 | The Unliscence | 100_numpy_exercises | 次の表現は正しいですか？
np.sqrt(-1) == np.emath.sqrt(-1) |
|
yesterday = np.datetime64('today') - np.timedelta64(1)
today = np.datetime64('today')
tomorrow = np.datetime64('today') + np.timedelta64(1) | code_generation | 680 | The Unliscence | 100_numpy_exercises | numpyを用いて、昨日、今日、明日の日付を取得するには？ |
|
Z = np.arange('2016-07', '2016-08', dtype='datetime64[D]')
print(Z) | code_generation | 681 | The Unliscence | 100_numpy_exercises | numpyを用いて、2016年7月に対応するすべての日付を取得するには？ |
|
A = np.ones(3)*1
B = np.ones(3)*2
np.add(A,B,out=B)
np.divide(A,2,out=A)
np.negative(A,out=A)
np.multiply(A,B,out=A) | code_generation | 682 | The Unliscence | 100_numpy_exercises | numpyを用いて、((A+B)*(-A/2))をコピーなしで計算しなさい。 |
|
Z = np.random.uniform(0,10,10)
print(Z - Z%1)
print(Z // 1)
print(np.floor(Z))
print(Z.astype(int))
print(np.trunc(Z)) | code_generation | 683 | The Unliscence | 100_numpy_exercises | numpyを用いて、正数のランダム配列の整数部分を4つの異なる方法で抽出しなさい。 |
|
Z = np.zeros((5,5))
Z += np.arange(5)
print(Z)
# without broadcasting
Z = np.tile(np.arange(0, 5), (5,1))
print(Z) | code_generation | 684 | The Unliscence | 100_numpy_exercises | numpyを用いて、行の値が0から4までの5x5の行列を作成しなさい。 |
|
def generate():
for x in range(10):
yield x
Z = np.fromiter(generate(),dtype=float,count=-1)
print(Z) | code_generation | 685 | The Unliscence | 100_numpy_exercises | numpyを用いて、10個の整数を生成するジェネレーター関数を考え、それを使って配列を構築しなさい。 |
|
Z = np.linspace(0,1,11,endpoint=False)[1:]
print(Z) | code_generation | 686 | The Unliscence | 100_numpy_exercises | numpyを用いて、0から1までの値を持つ、サイズ10のベクトルを作成しなさい。 |
|
Z = np.random.random(10)
Z.sort()
print(Z) | code_generation | 687 | The Unliscence | 100_numpy_exercises | numpyを用いて、サイズ10のランダムなベクトルを作成し、それをソートしなさい。 |
|
Z = np.arange(10)
np.add.reduce(Z) | code_generation | 688 | The Unliscence | 100_numpy_exercises | numpyを用いて、小さな配列をnp.sumより高速に合計するには？ |
|
# Assuming identical shape of the arrays and a tolerance for the comparison of values
equal = np.allclose(A,B)
print(equal)
# Checking both the shape and the element values, no tolerance (values have to be exactly equal)
equal = np.array_equal(A,B)
print(equal) | code_generation | 689 | The Unliscence | 100_numpy_exercises | numpyを用いて、2つのランダムな配列AとBを考え、それらが等しいかどうかをチェックしなさい。
A = np.random.randint(0,2,5)
B = np.random.randint(0,2,5) |
|
Z = np.zeros(10)
Z.flags.writeable = False
Z[0] = 1 | code_generation | 690 | The Unliscence | 100_numpy_exercises | numpyを用いて、配列をイミュータブル（読み取り専用）にしなさい。 |
|
Z = np.random.random((10,2))
X,Y = Z[:,0], Z[:,1]
R = np.sqrt(X**2+Y**2)
T = np.arctan2(Y,X)
print(R)
print(T) | code_generation | 691 | The Unliscence | 100_numpy_exercises | numpyを用いて、デカルト座標を表すランダムな10x2行列を考え、極座標に変換しなさい。 |
|
Z = np.random.random(10)
Z[Z.argmax()] = 0
print(Z) | code_generation | 692 | The Unliscence | 100_numpy_exercises | numpyを用いて、サイズ10のランダム・ベクトルを作成し、最大値を0に置き換えなさい。 |
|
Z = np.zeros((5,5), [('x',float),('y',float)])
Z['x'], Z['y'] = np.meshgrid(np.linspace(0,1,5),
np.linspace(0,1,5))
print(Z) | code_generation | 693 | The Unliscence | 100_numpy_exercises | numpyを用いて、[0,1]x[0,1]の領域をカバーする x と y の座標を持つ構造化配列を作成しなさい。 |
|
X = np.arange(8)
Y = X + 0.5
C = 1.0 / np.subtract.outer(X, Y)
print(np.linalg.det(C)) | code_generation | 694 | The Unliscence | 100_numpy_exercises | numpyを用いて、2つの配列XとYが与えられたとき、コーシー行列C（Cij =1/(xi - yj)）を構成しなさい。 |
|
for dtype in [np.int8, np.int32, np.int64]:
print(np.iinfo(dtype).min)
print(np.iinfo(dtype).max)
for dtype in [np.float32, np.float64]:
print(np.finfo(dtype).min)
print(np.finfo(dtype).max)
print(np.finfo(dtype).eps) | code_generation | 695 | The Unliscence | 100_numpy_exercises | numpyを用いて、各numpyスカラ型の表現可能な最小値と最大値を表示しなさい。 |
|
np.set_printoptions(threshold=float("inf"))
Z = np.zeros((40,40))
print(Z) | code_generation | 696 | The Unliscence | 100_numpy_exercises | numpyを用いて、配列のすべての値を表示しなさい。 |
|
Z = np.arange(100)
v = np.random.uniform(0,100)
index = (np.abs(Z-v)).argmin()
print(Z[index]) | code_generation | 697 | The Unliscence | 100_numpy_exercises | numpyを用いて、ベクトルの中で（与えられたスカラーに）最も近い値を見つけなさい。
Z = np.arange(100)
v = np.random.uniform(0,100) |
|
Z = np.zeros(10, [ ('position', [ ('x', float, 1),
('y', float, 1)]),
('color', [ ('r', float, 1),
('g', float, 1),
('b', float, 1)])])
print(Z) | code_generation | 698 | The Unliscence | 100_numpy_exercises | numpyを用いて、位置（x,y）と色（r,g,b）を表す構造化配列を作成しなさい。 |
|
Z = np.random.random((10,2))
X,Y = np.atleast_2d(Z[:,0], Z[:,1])
D = np.sqrt( (X-X.T)**2 + (Y-Y.T)**2)
print(D)
# Much faster with scipy
import scipy.spatial
Z = np.random.random((10,2))
D = scipy.spatial.distance.cdist(Z,Z)
print(D) | code_generation | 699 | The Unliscence | 100_numpy_exercises | numpyを用いて、座標を表す形状(10,2)のランダムなベクトルを考え、点ごとの距離を求めなさい。 |