我试图在很长一段时间内发现微观事件。为此，我将培训LSTM网络。
数据。每个时间样本的输入是11个不同的功能，有些标准化以适合0-1。输出将是两个类中的一个。
批处理。由于巨大的类不平衡，我已经分批提取了每60个样本的数据，其中至少5个将始终为1级，并且休息班来。通过这种方式，类不平衡从150：1减少到大约12：1然后我随机化了所有批次的顺序。
模型。我正在尝试训练LSTM，初始配置3个不同的单元格，有5个延迟步骤。我希望微观事件能够以至少3个时间步的顺序到达。
问题：当我尝试训练网络时，它会迅速收敛，说一切都属于大多数班级。当我实现加权损失函数时，在某个特定阈值处，它将改为说一切都属于少数类。我怀疑（没有专家）我的LSTM单元格中没有学习，或者我的配置已关闭？
以下是我的实施代码。我希望有人可以告诉我
ar_model.py
import numpy as np
import tensorflow as tf
from tensorflow.models.rnn import rnn
import ar_config
config = ar_config.get_config()
class ARModel(object):
def __init__(self, is_training=False, config=None):
# Config
if config is None:
config = ar_config.get_config()
# Placeholders
self._features = tf.placeholder(tf.float32, [None, config.num_features], name='ModelInput')
self._targets = tf.placeholder(tf.float32, [None, config.num_classes], name='ModelOutput')
# Hidden layer
with tf.variable_scope('lstm') as scope:
lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(config.num_hidden, forget_bias=0.0)
cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * config.num_delays)
self._initial_state = cell.zero_state(config.batch_size, dtype=tf.float32)
outputs, state = rnn.rnn(cell, [self._features], dtype=tf.float32)
# Output layer
output = outputs[-1]
softmax_w = tf.get_variable('softmax_w', [config.num_hidden, config.num_classes], tf.float32)
softmax_b = tf.get_variable('softmax_b', [config.num_classes], tf.float32)
logits = tf.matmul(output, softmax_w) + softmax_b
# Evaluate
ratio = (60.00 / 5.00)
class_weights = tf.constant([ratio, 1 - ratio])
weighted_logits = tf.mul(logits, class_weights)
loss = tf.nn.softmax_cross_entropy_with_logits(weighted_logits, self._targets)
self._cost = cost = tf.reduce_mean(loss)
self._predict = tf.argmax(tf.nn.softmax(logits), 1)
self._correct = tf.equal(tf.argmax(logits, 1), tf.argmax(self._targets, 1))
self._accuracy = tf.reduce_mean(tf.cast(self._correct, tf.float32))
self._final_state = state
if not is_training:
return
# Optimize
optimizer = tf.train.AdamOptimizer()
self._train_op = optimizer.minimize(cost)
@property
def features(self):
return self._features
@property
def targets(self):
return self._targets
@property
def cost(self):
return self._cost
@property
def accuracy(self):
return self._accuracy
@property
def train_op(self):
return self._train_op
@property
def predict(self):
return self._predict
@property
def initial_state(self):
return self._initial_state
@property
def final_state(self):
return self._final_state
ar_train.py
import os
from datetime import datetime
import numpy as np
import tensorflow as tf
from tensorflow.python.platform import gfile
import ar_network
import ar_config
import ar_reader
config = ar_config.get_config()
def main(argv=None):
if gfile.Exists(config.train_dir):
gfile.DeleteRecursively(config.train_dir)
gfile.MakeDirs(config.train_dir)
train()
def train():
train_data = ar_reader.ArousalData(config.train_data, num_steps=config.max_steps)
test_data = ar_reader.ArousalData(config.test_data, num_steps=config.max_steps)
with tf.Graph().as_default(), tf.Session() as session, tf.device('/cpu:0'):
initializer = tf.random_uniform_initializer(minval=-0.1, maxval=0.1)
with tf.variable_scope('model', reuse=False, initializer=initializer):
m = ar_network.ARModel(is_training=True)
s = tf.train.Saver(tf.all_variables())
tf.initialize_all_variables().run()
for batch_input, batch_target in train_data:
step = train_data.iter_steps
dict = {
m.features: batch_input,
m.targets: batch_target
}
session.run(m.train_op, feed_dict=dict)
state, cost, accuracy = session.run([m.final_state, m.cost, m.accuracy], feed_dict=dict)
if not step % 10:
test_input, test_target = test_data.next()
test_accuracy = session.run(m.accuracy, feed_dict={
m.features: test_input,
m.targets: test_target
})
now = datetime.now().time()
print ('%s | Iter %4d | Loss= %.5f | Train= %.5f | Test= %.3f' % (now, step, cost, accuracy, test_accuracy))
if not step % 1000:
destination = os.path.join(config.train_dir, 'ar_model.ckpt')
s.save(session, destination)
if __name__ == '__main__':
tf.app.run()
ar_config.py
class Config(object):
# Directories
train_dir = '...'
ckpt_dir = '...'
train_data = '...'
test_data = '...'
# Data
num_features = 13
num_classes = 2
batch_size = 60
# Model
num_hidden = 3
num_delays = 5
# Training
max_steps = 100000
def get_config():
return Config()
更新的架构：
# Placeholders
self._features = tf.placeholder(tf.float32, [None, config.num_features, config.num_delays], name='ModelInput')
self._targets = tf.placeholder(tf.float32, [None, config.num_output], name='ModelOutput')
# Weights
weights = {
'hidden': tf.get_variable('w_hidden', [config.num_features, config.num_hidden], tf.float32),
'out': tf.get_variable('w_out', [config.num_hidden, config.num_classes], tf.float32)
}
biases = {
'hidden': tf.get_variable('b_hidden', [config.num_hidden], tf.float32),
'out': tf.get_variable('b_out', [config.num_classes], tf.float32)
}
#Layer in
with tf.variable_scope('input_hidden') as scope:
inputs = self._features
inputs = tf.transpose(inputs, perm=[2, 0, 1]) # (BatchSize,NumFeatures,TimeSteps) -> (TimeSteps,BatchSize,NumFeatures)
inputs = tf.reshape(inputs, shape=[-1, config.num_features]) # (TimeSteps,BatchSize,NumFeatures -> (TimeSteps*BatchSize,NumFeatures)
inputs = tf.add(tf.matmul(inputs, weights['hidden']), biases['hidden'])
#Layer hidden
with tf.variable_scope('hidden_hidden') as scope:
inputs = tf.split(0, config.num_delays, inputs) # -> n_steps * (batchsize, features)
cell = tf.nn.rnn_cell.BasicLSTMCell(config.num_hidden, forget_bias=0.0)
self._initial_state = cell.zero_state(config.batch_size, dtype=tf.float32)
outputs, state = rnn.rnn(cell, inputs, dtype=tf.float32)
#Layer out
with tf.variable_scope('hidden_output') as scope:
output = outputs[-1]
logits = tf.add(tf.matmul(output, weights['out']), biases['out'])
答案 0 :(得分：3)
我不确定你的加权损失＆＃34;做你想做的事情：
ratio = (60.00 / 5.00)
class_weights = tf.constant([ratio, 1 - ratio])
weighted_logits = tf.mul(logits, class_weights)
这是在计算损失函数之前应用的（进一步我认为你也想要一个逐元素的乘法？你的比率是否高于1，这使得第二部分为负？）因此它会强制你的预测以某种方式表现在应用softmax之前。
如果你想加权损失，你应该在
之后申请loss = tf.nn.softmax_cross_entropy_with_logits(weighted_logits, self._targets)
通过权重的一些元素乘法。
loss = loss * weights
你的体重的形状如[2，]
但是，我不建议您使用加权损失。也许尝试将比例提高到1：6以上。
据我所知，您每层使用5个堆叠的LSTM，每个层有3个隐藏单元？
尝试删除多个rnn并使用单个LSTM / GRU（甚至可能只是一个vanilla RNN）并将隐藏的单位插入到大约100-1000。
通常当您遇到奇怪的行为网络问题时，最好：
直接打印模型中每个张量的形状和值，使用sess获取它然后打印它。您的输入数据，第一个隐藏的表示，您的预测，您的损失等。
您还可以使用张量流tf.Print() x_tensor = tf.Print(x_tensor, [tf.shape(x_tensor)])
在渐变上使用tensorboard摘要，精确度指标和直方图将揭示数据中可能解释某些行为的模式，例如导致爆炸权重的因素。也许你的忘记偏见可以通过某个层等无限或不跟踪渐变等。
您的数据集有多大？
你的序列有多长？
13个功能是分类还是连续？您不应该对分类变量进行标准化或将它们表示为整数，而应使用单热编码。
答案 1 :(得分：0)
Gunnar已经提出了许多好建议。对于这种架构，一般值得关注的一些小事情：
具体而言，您传递到网络的序列有多长？你说你有一个30k长的时间序列..我假设你正在传递这个序列的小节/样本？