金融领域的深度学习应用

### 金融领域的深度学习应用 #### 1. 金融数据的词嵌入模型训练 首先，我们使用以下代码将 GloVe 模型拟合到语料库： ```python model = GloVeModel(embedding_size=300, context_size=1) model.fit_to_corpus(corpus) model.train(num_epochs=100) ``` 训练好带有嵌入的模型后，我们需要开始推理以创建实体之间的关系。为此，我们要在数学空间中表示金融市场中的事件，这里将使用一种之前未见过的人工神经网络——神经张量网络（Neural Tensor Network，NTN）。 #### 2. 用于事件嵌入的神经张量网络（NTN） 神经张量网络（NTN）是一种新型的神经网络，它的工作方式类似于标准的前馈网络，但包含一个称为张量层的结构，而非标准的隐藏层。该网络最初是为了通过连接未连接的实体来完善知识库而开发的。例如，如果有实体 Google 和 YouTube，网络会帮助连接这两个实体，形成 Google -> Owns -> YouTube 的关系。它通过将不同的关系对作为张量传递通过网络，而不是通过单个向量，张量的每个切片代表两个实体之间不同的关系变体。 在事件驱动的交易领域，我们对 NTN 感兴趣是因为它能够关联实体。以下是构建 NTN 的详细步骤： 1. **定义 NTN 函数** ```python def NTN(batch_placeholders, corrupt_placeholder, init_word_embeds, entity_to_wordvec, num_entities, num_relations, slice_size, batch_size, is_eval, label_placeholders): d = 100 k = slice_size ten_k = tf.constant([k]) num_words = len(init_word_embeds) E = tf.Variable(init_word_embeds) W = [tf.Variable(tf.truncated_normal([d, d, k])) for r in range(num_relations)] V = [tf.Variable(tf.zeros([k, 2 * d])) for r in range(num_relations)] b = [tf.Variable(tf.zeros([k, 1])) for r in range(num_relations)] U = [tf.Variable(tf.ones([1, k])) for r in range(num_relations)] ent2word = [tf.constant(entity_i) - 1 for entity_i in entity_to_wordvec] entEmbed = tf.pack([tf.reduce_mean(tf.gather(E, entword), 0) for entword in ent2word]) predictions = list() for r in range(num_relations): e1, e2, e3 = tf.split(1, 3, tf.cast(batch_placeholders[r], tf.int32)) e1v = tf.transpose(tf.squeeze(tf.gather(entEmbed, e1, name='e1v' + str(r)), [1])) e2v = tf.transpose(tf.squeeze(tf.gather(entEmbed, e2, name='e2v' + str(r)), [1])) e3v = tf.transpose(tf.squeeze(tf.gather(entEmbed, e3, name='e3v' + str(r)), [1])) e1v_pos = e1v e2v_pos = e2v e1v_neg = e1v e2v_neg = e3v num_rel_r = tf.expand_dims(tf.shape(e1v_pos)[1], 0) preactivation_pos = list() preactivation_neg = list() for slice in range(k): preactivation_pos.append(tf.reduce_sum(e1v_pos * tf.matmul(W[r][:, :, slice], e2v_pos), 0)) preactivation_neg.append(tf.reduce_sum(e1v_neg * tf.matmul(W[r][:, :, slice], e2v_neg), 0)) preactivation_pos = tf.pack(preactivation_pos) preactivation_neg = tf.pack(preactivation_neg) temp2_pos = tf.matmul(V[r], tf.concat(0, [e1v_pos, e2v_pos])) temp2_neg = tf.matmul(V[r], tf.concat(0, [e1v_neg, e2v_neg])) preactivation_pos = preactivation_pos + temp2_pos + b[r] preactivation_neg = preactivation_neg + temp2_neg + b[r] activation_pos = tf.tanh(preactivation_pos) activation_neg = tf.tanh(preactivation_neg) score_pos = tf.reshape(tf.matmul(U[r], activation_pos), num_rel_r) score_neg = tf.reshape(tf.matmul(U[r], activation_neg), num_rel_r) if not is_eval: predictions.append(tf.pack([score_pos, score_neg])) else: predictions.append(tf.pack([score_pos, tf.reshape(label_placeholders[r], num_rel_r)])) predictions = tf.concat(1, predictions) return predictions ``` 2. **定义损失函数** ```python def loss(predictions, regularization): temp1 = tf.maximum(tf.sub(predictions[1, :], predictions[0, :]) + 1, 0) temp1 = tf.reduce_sum(temp1) temp2 = tf.sqrt(sum([tf.reduce_sum(tf.square(var)) for var in tf.trainable_variables()])) temp = temp1 + (regularization * temp2) return temp ``` 3. **定义训练算法** ```python def training(loss, learningRate): return tf.train.AdagradOptimizer(learningRate).minimize(loss) ``` 4. **定义评估函数** ```python def eval(predictions): print("predictions " + str(predictions.get_shape())) inference, labels = tf.split(0, 2, predictions) return inference, labels ``` #### 3. 使用卷积神经网络（CNN）预测事件 有了嵌入结构后，我们可以使用 CNN 基于该结构进行预测。通常，我们想到 CNN 时，会联想到计算机视觉任务，如识别图像中的物体。虽然 CNN 最初是为此设计的，但它也非常擅长检测文本中的特征。 在自然语言处理（NLP）中使用 CNN 时，我们用单词嵌入替换标准的像素输入。在典型的计算机视觉任务中，我们在图像的小区域上使用 CNN 的过滤器，而在 NLP 任务中，我们在嵌入矩阵的行上使用相同的滑动窗口。滑动窗口的宽度就是输入矩阵的宽度，通常这个窗口会同时查看大约两到五个单词（在我们的例子中是动作对）的嵌入。由于其压缩性质，这比使用循环神经网络（RNN）完成相同任务更高效。 以下是构建用于预测股票价格涨跌的 CNN 的步骤： 1. **导入必要的库并定义 CNN 类** ```python import tensorflow as tf import numpy as np class StockCNN(object): def __init__( self, sequence_length, num_classes, vocab_size, embedding_size, filter_sizes, num_filters, l2_reg_lambda=0.0): self.input_x = tf.placeholder(tf.int32, [None, sequence_length], name="input_x") self.input_y = tf.placeholder(tf.float32, [None, num_classes], name="input_y") self.dropout_keep_prob = tf.placeholder(tf.float32, name="dropout") l2_loss = tf.constant(0.0) with tf.device('/cpu:0'), tf.name_scope("embedding"): self.W = tf.Variable( tf.random_uniform([vocab_size, embedding_size], -1.0, 1.0), name="W") self.embedded_chars = tf.nn.embedding_lookup(self.W, self.input_x) self.embedded_chars_expanded = tf.expand_dims(self.embedded_chars, -1) pooled_outputs = [] for i, filter_size in enumerate(filter_sizes): with tf.name_scope("conv-maxpool-%s" % filter_size): filter_shape = [filter_size, embedding_size, 1, num_filters] W = tf.Variable(tf.truncated_normal(filter_shape, stddev=0.1), name="W") b = tf.Variable(tf.constant(0.1, shape=[num_filters]), name="b") conv = tf.nn.conv2d( self.embedded_chars_expanded, W, strides=[1, 1, 1, 1], padding="VALID", name="conv") h = tf.nn.relu(tf.nn.bias_add(conv, b), name="relu") pooled = tf.nn.max_pool( h, ksize=[1, sequence_length - filter_size + 1, 1, 1], strides=[1, 1, 1, 1], padding='VALID', name="pooling-layer") pooled_outputs.append(pooled) num_filters_total = num_filters * len(filter_sizes) self.h_pool = tf.concat(pooled_outputs, 3) self.h_pool_flat = tf.reshape(self.h_pool, [-1, num_filters_total]) with tf.name_scope("dropout"): self.h_drop = tf.nn.dropout(self.h_pool_flat, self.dropout_keep_prob) with tf.name_scope("output"): W = tf.get_variable( "W", shape=[num_filters_total, num_classes], initializer=tf.contrib.layers.xavier_initializer()) b = tf.Variable(tf.c ```