VSCodeのjupyter notebookが起動しない

最近VSCodeをアップデートしたところ、PythonのNotebookが起動しなくなりました。

Connection To IPython kernel: Connecting to kernel.

これでずーと待ったのちに、タイムアウト。

こちらに解決方法が!!

どうやら、Pythonのモジュールと干渉しているようですので、バージョンダウン。

python -m pip install 'traitlets==4.3.3' --force-reinstall

これで無事起動できました。

MacのRStanのインストールエラー

メモ

環境

  • MacOS 10.15.4
  • R 3.6.3

エラー

install.package("rstan")

こんなえらー

unistd.h:727:31: error: unknown type name 'uuid_t'; did you mean 'uid_t'?

対策

RからこれでOK

install.packages("Rcpp", repos="https://RcppCore.github.io/drat")

VSCodeでLatex

MacのVSCodeでLatexを使うためのセッティングの備忘録

環境

  • Mac OS 10.15
  • texlive 2019

settings.json

いろいろなところを参照し、最終的にこれ


{
    "latex-workshop.latex.tools": [
        {
            "name": "latexmk",
            "command": "latexmk",
            "args": [
                "-synctex=1",
                "-interaction=nonstopmode",
                "-file-line-error",
                "-outdir=%OUTDIR%",
                "%DOC%"
            ],
            "env": {}
        }
    ],

    "latex-workshop.latex.outDir": "%DIR%",
    "latex-workshop.view.pdf.viewer": "tab",
    "latex-workshop.view.pdf.zoom": "page-width",
}


$HOME/.latexmkrc

#!/usr/bin/env perl
$latex            = 'platex -synctex=1 -halt-on-error';
$latex_silent     = 'platex -synctex=1 -halt-on-error -interaction=batchmode';
$bibtex           = 'pbibtex -kanji=utf8';
$dvipdf           = 'dvipdfmx %O -o %D %S';
$makeindex        = 'mendex %O -o %D %S';
$max_repeat       = 5;
$pdf_mode         = 3; # 0: none, 1: pdflatex, 2: ps2pdf, 3: dvipdfmx
$aux_dir          = ".";
$out_dir          = ".";

実験

人工知能学会全国大会のテンプレートをダウンロードし、jsaiac.styとjsai.bstを同じディレクトリに入れておく

\documentclass[twocolumn]{ujarticle}
\usepackage{jsaiac}

\begin{document}
ああああ

\end{document}

このファイルを作成し保存するとコンパイルが始まり、PDFが作成される

KLDivergenceとJSDivergence

Pythonのコード作成したのでメモ

KLダイバージェンス

$$D_{KL}(P||Q) = \sum_x p(x) \, \log \frac{P(x)}{Q(x)}$$

JSダイバージェンス

$$D_{JS}(P||Q)=\frac{1}{2}\bigg\{ D_{KL}(P \, || \, R)+D_{KL}(Q \, || \, R) \bigg\}$$
$$R = \frac{P + Q}{2}$$

プログラム

ここを参考に

データ

まずはデータの準備


import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

np.random.seed(12345)
a=np.random.normal(40,10, size=200)
b=np.random.normal(70,15, size=100)
c=np.random.normal(30,2, size=70)
d=np.random.normal(150,10, size=150)

plt.figure()
plt.hist(a,alpha=0.3,bins=20,histtype="stepfilled",color="r",label="a")
plt.hist(b,alpha=0.3,bins=20,histtype="stepfilled",color="b",label="b")
plt.hist(c,alpha=0.3,bins=20,histtype="stepfilled",color="black",label="c")
plt.hist(d,alpha=0.3,bins=20,histtype="stepfilled",color="y",label="d")
plt.legend()
plt.show()

ヒストグラム

KLダイバージェンス


def KLDivergence(a, b, bins=20, epsilon=.00001):
    min_value=min(min(a),min(b))
    max_value=max(max(a),max(b))
    # サンプルをヒストグラムに, 共に同じ数のビンで区切る
    a_hist, _ = np.histogram(a, range=(min_value,max_value),bins=bins) 
    b_hist, _ = np.histogram(b, range=(min_value,max_value),bins=bins)
    
    # 合計を1にするために全合計で割る
    a_hist = (a_hist+epsilon)/np.sum(a_hist)
    b_hist = (b_hist+epsilon)/np.sum(b_hist)
    
    # 本来なら a の分布に0が含まれているなら0, bの分布に0が含まれているなら inf にする
    return np.sum([ai * np.log(ai / bi) for ai, bi in zip(a_hist, b_hist)])

JSダイバージェンス


def JSDivergence(a, b, bins=20, epsilon=.00001):
    min_value=min(min(a),min(b))
    max_value=max(max(a),max(b))
    # サンプルをヒストグラムに, 共に同じ数のビンで区切る
    a_hist, _ = np.histogram(a, range=(min_value,max_value),bins=bins) 
    b_hist, _ = np.histogram(b, range=(min_value,max_value),bins=bins)

    # 合計を1にするために全合計で割る
    a_hist = (a_hist+epsilon)/np.sum(a_hist)
    b_hist = (b_hist+epsilon)/np.sum(b_hist)
    
    r_hist = (a_hist + b_hist)/2.0
    
    ar= np.sum([ai * np.log(ai / ri) for ai, ri in zip(a_hist, r_hist)])
    br= np.sum([bi * np.log(bi / ri) for bi, ri in zip(b_hist, r_hist)])
    return (ar+br)/2.0

実験

まずはaとbの分布を調べます。


kl1=KLDivergence(a,b)
js1=JSDivergence(a,b)

kl2=KLDivergence(b,a)
js2=JSDivergence(b,a)
print("kl1=",kl1,",kl2=",kl2)
print("js1=",js1,",js2=",js2)

kl1= 4.804620164702722 ,kl2= 8.66117091460137
js1= 0.44568757334874426 ,js2= 0.44568757334874426

KLダイバージェンスはaとbを入れ替えると値が変わりますが、JSダイバージェンスでは同じです。

つぎに、分布間でのKLダイバージェンスとJSダイバージェンスの値を調べます


# 一致 
kl1=KLDivergence(a,a)
kl2=KLDivergence(a,a)
js=JSDivergence(a,a)
print("一致:kl1=",kl1,",kl2=",kl2,",js=",js)

# 含まれる
kl1=KLDivergence(a,c)
kl2=KLDivergence(c,a)
js=JSDivergence(a,c)
print("含有:kl1=",kl1,",kl2=",kl2,",js=",js)

# 重なる
kl1=KLDivergence(a,b)
kl2=KLDivergence(b,a)
js=JSDivergence(a,b)
print("重複:kl1=",kl1,",kl2=",kl2,",js=",js)

# 小別離
kl1=KLDivergence(b,d)
kl2=KLDivergence(d,b)
js=JSDivergence(b,d)
print("小離:kl1=",kl1,",kl2=",kl2,",js=",js)

# 大別離
kl1=KLDivergence(a,d)
kl2=KLDivergence(d,a)
js=JSDivergence(a,d)
print("大離:kl1=",kl1,",kl2=",kl2,",js=",js)

一致:kl1= 0.0 ,kl2= 0.0 ,js= 0.0
含有:kl1= 8.982185089568121 ,kl2= 1.5818474236167488 ,js= 0.3961382475750016
重複:kl1= 4.804620164702722 ,kl2= 8.66117091460137 ,js= 0.44568757334874426
小離:kl1= 14.585645733703917 ,kl2= 14.484008742932685 ,js= 0.6931379306807828
大離:kl1= 14.9325435215302 ,kl2= 15.170878470071264 ,js= 0.6931412821202988

結果を見ると、距離の遠い順にKLダイバージェンス、JSダイバージェンスの値が大きくなっています。KLダイバージェンスの場合には、どちらを基準にするかによって変わってくるので注意が必要みたいですね。

BERTモデルをPytorchのモデルへ変換

Tensorflowで作成したBERTモデルを、Pytorchへ変換します。

こちらに方法が書いています。

モデル

モデルを自分で計算して作ってもいいのですが、公開しているものがあるので、そちらを使います。

KNP

こちらはKNPを使って分かち書きしたWikipedia日本語版を元に作成しています。
あまりKNPを使ったことはないのですが、実際に使うときにはMeCabで分かち書きをしても大丈夫でしょう。

SentencePiece

こちらのものは同じく日本語Wikipediaを用いて、SentencePieceによる分かち書きをしたものです。

Transformers

Pytorchで用いるのライブラリです。以下のコマンドでインストールしておきます。

pip install transformers

変換

SentencePieceで作成したモデルにはPytorch用のモデルがついていませんので、変換してみます。
こちらには以下のファイルが含まれています。

model.ckpt-1400000.meta
bert_config.json                       
model.ckpt-1400000.data-00000-of-00001 
wiki-ja.model
model.ckpt-1400000.index               
wiki-ja.vocab

このコマンドでpytorch_model.binというファイルへ変換します。

transformers bert  model.ckpt-1400000 bert_config.json pytorch_model.bin

リモートサーバのtensorflowの結果を表示する

大学のサーバなどで計算した後の結果を確認する時に、
わざわざ計算結果のデータをローカルに持ってくるのは面倒だったりします。
リモートの結果を表示できないかと言うことで、SSHポートフォワードを使って
ローカルでも表示できるようにします。

tensorflowダウンロード

$ git clone https://github.com/tensorflow/tensorflow
$ cd tensorflow

使用しているtensorflowは1.15なのでバージョンを合わせます

$ git branch -a
$ git checkout -b r1.15 origin/r1.15

これで1.15のブランチになります。以下のコマンドで確認。

$ git branch
  master
* r1.15

mnist

mnistを計算してみます

$ cd /tensorflow/examples/tutorials/mnist
$ mkdir logs
$ python fully_connected_feed.py --log_dir=logs

logs以下にファイルが作成されていることを確認します

$ ls logs
checkpoint                               model.ckpt-1999.meta
events.out.tfevents.1573779801.vpcc-101  model.ckpt-999.data-00000-of-00001
model.ckpt-1999.data-00000-of-00001      model.ckpt-999.index
model.ckpt-1999.index                    model.ckpt-999.meta

ポートフォワード

サーバが外部公開されていないなど、ローカルPCから直接ブラウザでアクセスできないときのために、SSH
ポートフォワードを使用します。
こちらを参考に、
macから繋ぐためにはターミナルから以下のコマンドを打ち込みます。

$ ssh -L 8081:remotehost:10010 remotehost -lusername

これは、リモートサーバの10010ポートをローカルの8081ポートで見れるようにするためのものだと思えばいいです。

まずは、動くかどうか確認です。
リモートでpython簡易サーバを立ち上げます

$ python -m http.server 10010

ブラウザでhttp://localhost:8081にアクセスし確認します。
ディレクトリリストが見えることがわかります。
Ctrl+Cでシャットダウンします

tensorboardによる可視化

先ほど計算した、mnistの計算結果を表示してみます。

$ tensorboard --logdir=logs --port 10010
TensorBoard 1.15.0 at http://remotehost:10010/ (Press CTRL+C to quit)

ブラウザでhttp://localhost:8081にアクセスします

表示されました。

numpyのエラー

tensorflowのサンプルを動かそうとしたときのエラー

4$ python fully_connected_feed.py 
RuntimeError: module compiled against API version 0xc but this version of numpy is 0xb
ImportError: numpy.core.multiarray failed to import
ImportError: numpy.core.umath failed to import
ImportError: numpy.core.umath failed to import
2019-11-15 09:55:15.959592: F tensorflow/python/lib/core/bfloat16.cc:675] Check failed: PyBfloat16_Type.tp_base != nullptr 
中止 (コアダンプ)

どうやら、numpyが壊れているらしい?

$ pip install -U numpy 

これで解決

Rstudioの環境変数

RStudioを好んで使っています。

Mac版RStudioはHomeBrewでインストールすることができます

brew cask install rstudio

この時、アプリケーションフォルダ内にRStudioのアイコンが表示されます。
このアイコンをクリックして起動すると、Bashシェルの環境変数を読み込んでくれません。

自分の場合、データフォルダをDATA環境変数に入れることにより、大学で使っている
サーバのデータフォルダとの物理ディレクトリの違いを吸収するようにしています。
例えば


data.file<-paste(Sys.getenv("DATA"),"/sample.txt",sep="")

こんな感じで記述しておけば、
サーバでは /work/user/data/sample.txtのディレクトリにあるファイル
ローカルPCでは /home/user/data/sample.txtのディレクトリにあるファイルでも、
環境変数DATAにサーバでは/work/user/data/、ローカルPCでは/home/user/data/
を設定しておけば、プログラムを変更する必要がありません。

しかし、Rstudioを入れたそのままではこの環境変数が使えません。

これを解決するには、~/.Renvironに環境変数を記述しておけばOKです。

~/.Renviron

DATA=${HOME}/data

chainerでCRFを用いて固有表現抽出

このあたりを参考に書き直してみました。
CRFなどの解説はリンク先を参照のこと

仕様

単語列から名詞の塊を抜き出す。
英語で複合名詞など複数の名詞で構成される名詞の塊にフラグをつける。
下記の例では、Oが名詞以外、Bが名詞の開始位置、Iが複合名詞の2個目以降を示している。

 the wall street journal reported today that apple corporation made money 
O    B   I      I      I      O        O    O     B     I          O    O      O

これを、Linearの1層で学習し、CRFで出力する

コード



import numpy as np
import argparse
import os
import chainer
import chainer.functions as F
import chainer.links as L
from chainer import training, optimizers, initializers,reporter
from chainer.training import extensions
import random
from itertools import chain


# my model
class IconDetector(chainer.Chain):

    def __init__(self, n_vocab, window, n_label, n_unit):
        super().__init__()
        with self.init_scope():
            self.embed=L.EmbedID(n_vocab, n_unit)
            self.lin=L.Linear(n_unit , n_label)
            self.crf=L.CRF1d(n_label=n_label)
        self.window=window

    def forward(self, xs):
        l = xs.shape[1]
        ys = []
        # 1 wordづつ
        for i in range(l):
            x = self.embed(xs[:,i])
            h = F.tanh(x)
            y = self.lin(h)
            ys.append(y)
        return ys #[window, batchsize, n_label]

    def __call__(self, xs, ts):
        """error function"""
        ys = self.forward(xs)
        ts = [ts[:, i] for i in range(ts.data.shape[1])] # [window,batchsize]
        loss = self.crf(ys, ts)
        reporter.report({'loss': loss}, self)
        return loss

    def predict(self, xs):
        ts = self.forward(xs)
        _, ys = self.crf.argmax(ts)
        return ys

class WindowIterator(chainer.dataset.Iterator):

    def __init__(self, text, label, window, batch_size, shuffle= True,repeat=True):
        self.text = np.asarray(text, dtype=np.int32)
        self.label = np.asarray(label, dtype=np.int32)
        self.window = window
        self.batch_size = batch_size
        self._repeat = repeat
        self._shuffle=shuffle

        if self._shuffle:
            self.order = np.random.permutation(
                len(text) - window ).astype(np.int32)

        else:
            self.order=np.array(list(range(len(text) - window )))
        self.current_position = 0
        self.epoch = 0
        self.is_new_epoch = False

    def __next__(self):
        if not self._repeat and self.epoch > 0:
            raise StopIteration

        i = self.current_position
        i_end = i + self.batch_size
        position = self.order[i: i_end]
        offset = np.concatenate([np.arange(0, self.window )])
        pos = position[:, None] + offset[None, :]
        context = self.text.take(pos)
        doc = self.label.take(pos)

        if i_end >= len(self.order):
            np.random.shuffle(self.order)
            self.epoch += 1
            self.is_new_epoch = True
            self.current_position = 0
        else:
            self.is_new_epoch = False
            self.current_position = i_end

        return  context, doc

    @property
    def epoch_detail(self):
        return self.epoch + float(self.current_position) / len(self.order)

@chainer.dataset.converter()
def convert(batch, device):
    context, doc = batch
    xp = device.xp
    doc = xp.asarray(doc)
    context = xp.asarray(context)
    return context, doc


def main():

    parser = argparse.ArgumentParser()
    parser.add_argument('--device', '-d', type=str, default='-1',
                        help='Device specifier. Either ChainerX device '
                        'specifier or an integer. If non-negative integer, '
                        'CuPy arrays with specified device id are used. If '
                        'negative integer, NumPy arrays are used')
    parser.add_argument('--window', '-w', default=5, type=int,
                        help='window size')
    parser.add_argument('--batchsize', '-b', type=int, default=2,
                        help='learning minibatch size')
    parser.add_argument('--epoch', '-e', default=100, type=int,
                        help='number of epochs to learn')
    parser.add_argument('--out', default=os.environ["WORK"]+"/summarization/sm_icgw/result",
                        help='Directory to output the result')

    args = parser.parse_args()

    random.seed(12345)
    np.random.seed(12345)

    device = chainer.get_device(args.device)

    training_data = [(
        " the wall street journal reported today that apple corporation made money ".split(),
        "O B I I I O O O B I O O O".split()
    ), (
        " georgia tech is a university in georgia ".split(),
        "O B I O O O O B O".split()
    )]

    validation_data = [(' georgia tech reported today '.split(),"O B I O O O".split())]

    word2id={"":0,"":1,"":2,"":3}
    label2id={"B":0,"I":1,"O":2}

    def get_dataset(data,is_train=True):
        texts=[]
        labels=[]
        for word,attrib in data:
            for w,a in zip(word,attrib):
                if w not in word2id:
                    if is_train:
                        word2id[w]=len(word2id)
                    else:
                        w=""
                texts.append(word2id[w])
                labels.append(label2id[a])
        return texts,labels

    train_text,train_label=get_dataset(training_data)
    valid_text,valid_label=get_dataset(validation_data,False)

    n_vocab=len(word2id)
    n_label=len(label2id)
    n_unit=n_vocab//2
    model=IconDetector(n_vocab=n_vocab, window=args.window,n_label=n_label,n_unit=n_unit)

    model.to_device(device)
    optimizer = optimizers.Adam()
    optimizer.setup(model)

    train_iter = WindowIterator(train_text, train_label, args.window, args.batchsize)
    valid_iter = WindowIterator(valid_text, valid_label, args.window,args.batchsize, repeat=False, shuffle=False)

    updater = training.StandardUpdater(train_iter, optimizer, converter=convert, device=device)
    trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
    trainer.extend(extensions.LogReport(),trigger=(10, 'epoch'))
    trainer.extend(extensions.PrintReport(['epoch', 'main/loss','validation/main/loss']))
    #trainer.extend(extensions.ProgressBar())

    trainer.extend(extensions.Evaluator(valid_iter, model,converter=convert, device=device),trigger=(10, 'epoch'))
    trainer.run()

    # testing
    testing_data = [(' the street journal is a university '.split(),"O B I I O O O O".split())]
    test_text,test_label=get_dataset(testing_data,False)
    with chainer.using_config('train', False), \
            chainer.using_config('enable_backprop', False):
        ys=model.predict(np.array([test_text],dtype=np.int32))

        ys=list(chain.from_iterable(ys))
        print(ys)
        print(test_label)

if __name__ == '__main__':
    main()

実行結果

epoch       main/loss   validation/main/loss
10          6.24186     7.77101               
20          5.43089     6.29938               
30          3.16409     5.09233               
40          2.68146     4.02053               
50          1.47248     3.07853               
60          1.63073     2.28975               
70          1.13568     1.67798               
80          0.842947    1.22796               
90          0.364242    0.912943              
100         0.658557    0.692736              
[2, 0, 1, 1, 2, 2, 2, 2]
[2, 0, 1, 1, 2, 2, 2, 2]

ちゃんと学習できているようです

LSTMでSIN波を学習させる

このあたりを参考に書き直してみました。

プログラム


import chainer
import chainer.links as L
import chainer.functions as F
import numpy as np
from chainer import optimizers
from chainer.datasets import tuple_dataset
from chainer import reporter
import matplotlib.pyplot as plt

class MyClassifier(chainer.Chain):

    def __init__(self, seqlen, out_units=1, dropout=0.1):
        super(MyClassifier, self).__init__()
        with self.init_scope():
            self.encoder = L.LSTM(seqlen, out_units)
        self.dropout = dropout

    def forward(self, xs, ys):
        concat_outputs =F.concat( self.predict(xs), axis=0)
        concat_truths = F.concat(ys, axis=0)

        loss = F.mean_squared_error(concat_outputs, concat_truths)
        reporter.report({'loss': loss}, self)
        return loss

    def predict(self, xs, softmax=False, argmax=False):
        concat_encodings = F.dropout(self.encoder(xs), ratio=self.dropout)
        if softmax:
            return F.softmax(concat_encodings).array
        elif argmax:
            return self.xp.argmax(concat_encodings.array, axis=1)
        else:
            return concat_encodings

    def reset_state(self):
        self.encoder.reset_state()


# main
if __name__ == "__main__":

    # データ
    def get_dataset(N,st=0,ed=2*np.pi):
        xval = np.linspace(st,ed, N)  # x軸の値
        y = np.sin(xval)              # y軸の値
        return y,xval

    # 0-2piまでを100等分
    N = 100
    train_ds,train_xval = get_dataset(N)

    # valid
    N_valid = 50
    valid_ds,valid_xval = get_dataset(N_valid,2*np.pi,3*np.pi)


    # 学習パラメータ
    batchsize = 10
    n_epoch = 1000
    seqlen=10
    gpu = -1

    def seq_split(seqlen,ds,xval):
        X=[]    # seqlen 分Y軸の値を取り出し
        y=[]    # seqlen+1のY軸の値を正解として格納
        ret_xval=[]   # その時のX軸の値
        for i in range(len(ds)-seqlen-1):
            X.append(np.array(ds[i:i+seqlen]))
            y.append(np.array([ds[i+seqlen]]))
            ret_xval.append(xval[i+seqlen])
        return X,y,ret_xval


    X_train,y_train,_=seq_split(seqlen,train_ds,train_xval)
    train=tuple_dataset.TupleDataset(np.array(X_train, dtype=np.float32), np.array(y_train, dtype=np.float32))

    X_valid,y_valid,_=seq_split(seqlen,valid_ds,valid_xval)
    valid=tuple_dataset.TupleDataset(np.array(X_valid, dtype=np.float32), np.array(y_valid, dtype=np.float32))

    # モデル作成
    model = MyClassifier(seqlen=seqlen)
    optimizer = optimizers.Adam()
    optimizer.setup(model)

    train_iter = chainer.iterators.SerialIterator(train, batchsize)
    valid_iter = chainer.iterators.SerialIterator(valid, batchsize, repeat=False, shuffle=False)

    updater = chainer.training.updaters.StandardUpdater(train_iter, optimizer, device=gpu)
    trainer = chainer.training.Trainer(updater, (n_epoch, 'epoch'), out="snapshot")

    trainer.extend(chainer.training.extensions.Evaluator(valid_iter, model, device=gpu))
    trainer.extend(chainer.training.extensions.dump_graph('main/loss'))

    # Take a snapshot for each specified epoch
    frequency = 10
    trainer.extend(chainer.training.extensions.snapshot(filename="snapshot_cureent"), trigger=(frequency, 'epoch'))

    trainer.extend(chainer.training.extensions.LogReport(trigger=(10, "epoch")))
    trainer.extend(chainer.training.extensions.PrintReport(
        ["epoch", "main/loss", "validation/main/loss", "elapsed_time"]))
    # trainer.extend(chainer.training.extensions.ProgressBar())
    trainer.extend(chainer.training.extensions.PlotReport(['main/loss', 'validation/main/loss'], trigger=(10, "epoch"),
                                                          filename="loss.png"))
    trainer.run()


    # テストデータ
    N_test = 50
    test_ds,test_xval = get_dataset(N_test,3*np.pi,4*np.pi)
    X_test,y_test,x=seq_split(seqlen,test_ds,test_xval)

    with chainer.using_config("train", False), chainer.using_config('enable_backprop', False):
        model_predict=[]
        for xt in X_test:
            model_predict.append(model.predict(np.array([xt],dtype=np.float32)))
        y=F.concat(y_test,axis=0).data
        p=F.concat(model_predict, axis=0).data
        plt.plot(x,y,color="b")
        plt.plot(x,p,color="r")
        plt.show()

xが0から2πまでをN=100等分し、その時のyの値を学習します

出力

epoch       main/loss   validation/main/loss  elapsed_time
10          0.412313    0.22419               0.680705      
20          0.34348     0.176668              1.45632       
30          0.322577    0.157206              2.21422       
40          0.313264    0.142921              3.01513       
50          0.286482    0.156473              3.79678       
60          0.271693    0.145663              4.5567        
70          0.26161     0.153716              5.27208       
80          0.249188    0.148146              6.01087       
90          0.229289    0.135516              6.7483        
100         0.235577    0.135556              7.4885        
110         0.210943    0.122771              8.23302       
120         0.206481    0.125734              8.96983       
130         0.199006    0.110476              9.70469       
140         0.185752    0.105235              10.443        
150         0.170962    0.0997412             11.2183       
160         0.17236     0.0935808             11.9595       
170         0.159314    0.08463               12.7018       
180         0.159687    0.0768325             13.4395       
190         0.137582    0.0830929             14.18         
200         0.146723    0.0774658             14.9236       
210         0.144295    0.0731078             15.6569       
220         0.137017    0.0640324             16.3937       
230         0.120282    0.0675966             17.1413       
240         0.122946    0.065422              17.886        
250         0.112485    0.0601812             18.6319       
260         0.115785    0.0622176             19.3996       
270         0.108337    0.0572397             20.1444       
280         0.113232    0.0529092             20.8836       
290         0.111058    0.0531542             21.6315       
300         0.0978656   0.0537841             22.367        
310         0.107318    0.0500048             23.1059       
320         0.100115    0.0471024             23.8513       
330         0.0941351   0.0466782             24.6336       
340         0.0992865   0.0462204             25.4045       
350         0.0909913   0.0444264             26.1611       
360         0.0862495   0.04312               26.9144       
370         0.0855708   0.0425527             27.7444       
380         0.0872798   0.0402729             28.5102       
390         0.0902846   0.0412268             29.265        
400         0.0840953   0.0421445             30.0178       
410         0.0782678   0.0389577             30.7646       
420         0.0813485   0.0383136             31.5095       
430         0.0892697   0.0380051             32.2756       
440         0.0784913   0.0378043             33.0377       
450         0.077315    0.0382185             33.7859       
460         0.0797667   0.0370378             34.5328       
470         0.085258    0.0353085             35.2766       
480         0.0904794   0.0364417             36.0569       
490         0.0760617   0.0347273             36.7939       
500         0.0776822   0.0349566             37.5342       
510         0.0753997   0.0348118             38.2753       
520         0.084298    0.0351735             39.0137       
530         0.0827682   0.0336927             39.7616       
540         0.0885914   0.032941              40.4968       
550         0.0755433   0.0328157             41.2496       
560         0.0864087   0.0329004             41.9931       
570         0.0696817   0.0333915             42.7455       
580         0.0673041   0.0310085             43.4925       
590         0.0695492   0.0322058             44.2814       
600         0.0626493   0.0321012             45.0249       
610         0.0780004   0.0311171             45.7709       
620         0.0842924   0.0313559             46.5104       
630         0.0869392   0.0310007             47.253        
640         0.0807384   0.0300728             48.0017       
650         0.061898    0.0308209             48.799        
660         0.0656733   0.0304086             49.5613       
670         0.0785108   0.0301482             50.3314       
680         0.0748608   0.0305042             51.1063       
690         0.0720685   0.0300295             51.874        
700         0.071668    0.0300219             52.6741       
710         0.0577448   0.0295377             53.4246       
720         0.07059     0.0295795             54.1749       
730         0.0677278   0.0291774             54.9278       
740         0.0747214   0.0296802             55.6766       
750         0.0796093   0.0296162             56.4188       
760         0.0659514   0.0292572             57.1649       
770         0.0651634   0.0294423             57.9178       
780         0.0732363   0.0291244             58.6651       
790         0.0750731   0.0292386             59.54         
800         0.0768709   0.0289816             60.4078       
810         0.0712155   0.0293295             61.1858       
820         0.0613775   0.0290006             62.1138       
830         0.0674119   0.0289881             62.9673       
840         0.0720593   0.0289764             63.7099       
850         0.0653162   0.028784              64.4681       
860         0.0873163   0.0285498             65.2305       
870         0.0674722   0.0286272             65.9901       
880         0.0718548   0.0282714             66.7374       
890         0.0659643   0.028604              67.5049       
900         0.0790577   0.0286806             68.2621       
910         0.0734288   0.028266              69.0192       
920         0.0664547   0.0282677             69.7996       
930         0.0799885   0.0284383             70.5581       
940         0.0687402   0.0284575             71.3119       
950         0.0721005   0.0282444             72.0637       
960         0.0750532   0.0282908             72.8485       
970         0.0663102   0.0282821             73.6094       
980         0.0807248   0.0281474             74.3701       
990         0.0730301   0.0283711             75.155        
1000        0.0674249   0.0282971             75.9349    

テスト結果

青い線が正解で赤い線が学習したのちの予測結果です。
Xの値を与えて、Yを予測した結果ですが、あまりうまく予測できていませんね