ニューラルネットワークがゼロ出力に収束する

Question

私はこのニューラルネットワークを訓練して、一部のデータの予測を試みています。 小さなデータセット（約100レコード）で試してみましたが、それは魅力的なように機能していました。次に、新しいデータセットをプラグインし、NNが0の出力に収束し、誤差が正のサンプルの数とサンプルの総数の比にほぼ収束することがわかりました。

私のデータセットはイエス/ノーフィーチャー（1.0/0.0）で構成され、地面の真実はイエス/ノーでもあります。

私の仮定：
1）が出力0で極小値です（私は学習率とinit重みの多くの値を試してみました、常にそこに収束しているようだ）
2）自分の体重の更新は（間違っていますしかし私によく見える）
3）それは単なる出力スケーリングの問題です。出力（出力/最大（出力）と出力/平均（出力））の縮尺を調整しようとしましたが、以下のコードで見られるように結果が良くありません。私は別の方法でそれをスケールする必要がありますか？ソフトマックス？ここ

はコードです：

import pandas as pd 
import numpy as np 
import pickle 
import random 
from collections import defaultdict 

alpha = 0.1 
N_LAYERS = 10 
N_ITER = 10 
#N_FEATURES = 8 
INIT_SCALE = 1.0 

train = pd.read_csv("./data/prediction.csv") 

y = train['y_true'].as_matrix() 
y = np.vstack(y).astype(float) 
ytest = y[18000:] 
y = y[:18000] 

X = train.drop(['y_true'], axis = 1).as_matrix() 
Xtest = X[18000:].astype(float) 
X = X[:18000] 

def tanh(x,deriv=False): 
    if(deriv==True): 
     return (1 - np.tanh(x)**2) * alpha 
    else: 
     return np.tanh(x) 

def sigmoid(x,deriv=False): 
    if(deriv==True): 
     return x*(1-x) 
    else: 
     return 1/(1+np.exp(-x)) 

def relu(x,deriv=False): 
    if(deriv==True): 
     return 0.01 + 0.99*(x>0) 
    else: 
     return 0.01*x + 0.99*x*(x>0) 

np.random.seed() 

syn = defaultdict(np.array) 

for i in range(N_LAYERS-1): 
    syn[i] = INIT_SCALE * np.random.random((len(X[0]),len(X[0]))) - INIT_SCALE/2 
syn[N_LAYERS-1] = INIT_SCALE * np.random.random((len(X[0]),1)) - INIT_SCALE/2 

l = defaultdict(np.array) 
delta = defaultdict(np.array) 

for j in xrange(N_ITER): 
    l[0] = X 
    for i in range(1,N_LAYERS+1): 
     l[i] = relu(np.dot(l[i-1],syn[i-1])) 

    error = (y - l[N_LAYERS]) 

    e = np.mean(np.abs(error)) 
    if (j% 1) == 0: 
     print "\nIteration " + str(j) + " of " + str(N_ITER) 
     print "Error: " + str(e) 

    delta[N_LAYERS] = error*relu(l[N_LAYERS],deriv=True) * alpha 
    for i in range(N_LAYERS-1,0,-1): 
     error = delta[i+1].dot(syn[i].T) 
     delta[i] = error*relu(l[i],deriv=True) * alpha 

    for i in range(N_LAYERS): 
     syn[i] += l[i].T.dot(delta[i+1]) 



pickle.dump(syn, open('neural_weights.pkl', 'wb')) 

# TESTING with f1-measure 
# RECALL = TRUE POSITIVES/(TRUE POSITIVES + FALSE NEGATIVES) 
# PRECISION = TRUE POSITIVES/(TRUE POSITIVES + FALSE POSITIVES) 

l[0] = Xtest 
for i in range(1,N_LAYERS+1): 
    l[i] = relu(np.dot(l[i-1],syn[i-1])) 

out = l[N_LAYERS]/max(l[N_LAYERS]) 

tp = float(0) 
fp = float(0) 
fn = float(0) 
tn = float(0) 

for i in l[N_LAYERS][:50]: 
    print i 

for i in range(len(ytest)): 
    if out[i] > 0.5 and ytest[i] == 1: 
     tp += 1 
    if out[i] <= 0.5 and ytest[i] == 1: 
     fn += 1 
    if out[i] > 0.5 and ytest[i] == 0: 
     fp += 1 
    if out[i] <= 0.5 and ytest[i] == 0: 
     tn += 1 

print "tp: " + str(tp) 
print "fp: " + str(fp) 
print "tn: " + str(tn) 
print "fn: " + str(fn) 

print "\nprecision: " + str(tp/(tp + fp)) 
print "recall: " + str(tp/(tp + fn)) 

f1 = 2 * tp /(2 * tp + fn + fp) 
print "\nf1-measure:" + str(f1) 

、これが出力されます：

あなたが収束するネットワークの10層が必要になり、その可能性は低いモデルに基づいて

Iteration 0 of 10 
Error: 0.222500767998 

Iteration 1 of 10 
Error: 0.222500771157 

Iteration 2 of 10 
Error: 0.222500774321 

Iteration 3 of 10 
Error: 0.22250077749 

Iteration 4 of 10 
Error: 0.222500780663 

Iteration 5 of 10 
Error: 0.222500783841 

Iteration 6 of 10 
Error: 0.222500787024 

Iteration 7 of 10 
Error: 0.222500790212 

Iteration 8 of 10 
Error: 0.222500793405 

Iteration 9 of 10 
Error: 0.222500796602 


[ 0.] 
[ 0.] 
[ 5.58610895e-06] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 4.62182626e-06] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 5.58610895e-06] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 4.62182626e-06] 
[ 0.] 
[ 0.] 
[ 5.04501079e-10] 
[ 5.58610895e-06] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 5.04501079e-10] 
[ 0.] 
[ 0.] 
[ 4.62182626e-06] 
[ 0.] 
[ 5.58610895e-06] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 5.58610895e-06] 
[ 0.] 
[ 0.] 
[ 0.] 
[ 5.58610895e-06] 
[ 0.] 
[ 1.31432294e-05] 

tp: 28.0 
fp: 119.0 
tn: 5537.0 
fn: 1550.0 

precision: 0.190476190476 
recall: 0.0177439797212 

f1-measure:0.0324637681159 

Answer 1

。

もっと隠れたノードを持つ3層ネットワークを試してみてください。 Feedforwardの問題の大半は、効果的に収束させるために1つの隠れ層が必要になります。

深いNNは浅いものを訓練するのがはるかに困難です。

他の人のように、学習率ははるかに小さくすべきだと言っています[.01、.3]はまともな範囲ですが、さらに反復回数がはるかに多くなる必要があります。

10レイヤーが多すぎます。