精华内容
下载资源
问答
  • 这段时间学习Python,调通了基于监督学习的LSTM神经网络预测模型代码,在一般代码的基础上,做了单步和多步通用版的改进。调通的代码附后,供各位大咖指正。 虽然代码调通了,但是发现输出的预测结果均滞后于实际值...

    这段时间学习Python,调通了基于监督学习的LSTM神经网络预测模型代码,在一般代码的基础上,做了单步和多步通用版的改进。调通的代码附后,供各位大咖指正。
            虽然代码调通了,但是发现输出的预测结果均滞后于实际值,更像是对原始数据的拟合而不是预测,想请教一下: 
            1、代码问题在哪里?     
            2、如果代码没问题,预测功能是怎么体现的?   
            3、如果有类似的群,方便也请大咖告知,可以加群学习,谢谢。
     
    代码如下:

    import pandas as pd
    # 设置显示的最大列、宽等参数,消掉打印不完全中间的省略号
    pd.set_option('display.max_columns', 1000)
    pd.set_option('display.width', 1000)
    pd.set_option('display.max_colwidth', 1000)
    import matplotlib.pyplot as plt
    import tensorflow as tf
    import os
    from pandas import read_excel
    import numpy as np
    from pandas import DataFrame
    from pandas import concat
    from sklearn.preprocessing import MinMaxScaler
    from keras.models import Sequential, load_model
    from keras.layers import LSTM, Dense, Dropout, BatchNormalization
    from numpy import concatenate
    from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
    from math import sqrt
    
    # 定义参数
    start_rate = 0.99
    end_rate = 0.01
    n_features = 21  # 特征值数
    n_predictions = 1  # 预测值数
    delay = 5  # 目标是未来第5个交易日
    test_trade_date = []
    
    
    # 定义字符串转换为浮点型
    def str_to_float(s):
        s = s[:-1]
        s_float = float(s)
        return s_float
    
    
    # 定义series_to_supervised()函数
    # 将时间序列转换为监督学习问题
    def series_to_supervised(data, n_in=1, n_out=1, dropnan=True):
        """
        Frame a time series as a supervised learning dataset.
        Arguments:
            data: Sequence of observations as a list or NumPy array.
            n_in: Number of lag observations as input (X).
            n_out: Number of observations as output (y).
            dropnan: Boolean whether or not to drop rows with NaN values.
        Returns:
            Pandas DataFrame of series framed for supervised learning.
        """
        n_vars = 1 if type(data) is list else data.shape[1]
        df = DataFrame(data)
        cols, names = list(), list()
        # input sequence (t-n, ... t-1)输入序列
        for i in range(n_in, 0, -1):
            cols.append(df.shift(i))
            names += [('var%d(t-%d)' % (j + 1, i)) for j in range(n_vars)]
        # forecast sequence (t, t+1, ... t+n)预测序列
        for i in range(0, n_out):
            cols.append(df.shift(-i))
            if i == 0:
                names += [('var%d(t)' % (j + 1)) for j in range(n_vars)]
            else:
                names += [('var%d(t+%d)' % (j + 1, i)) for j in range(n_vars)]
        # put it all together
        agg = concat(cols, axis=1)
        agg.columns = names
        # drop rows with NaN values
        nan_rows = agg[agg.isnull().T.any().T]
        if dropnan:
            agg.dropna(inplace=True)
        return agg
    
    
    def generator(tsc='000001', delay=5):
        # 读取文件,删除不必要项
        stock_data = pd.read_csv(r"c:\python\日k线数据\%s.csv" % tsc, index_col=0)  # 读入股票数据,防止第一列被当作数据,加入index_col=0
        stock_data['schange'] = stock_data['close']
        stock_data.reset_index(drop=True, inplace=True)
        stock_data.drop(['ts_code', 'trade_date', 'pre_close', 'change', 'pct_chg'], axis=1,
                        inplace=True)  # df=df.iloc[:,1:13]
        # 缺失值填充
        stock_data.fillna(method='bfill', inplace=True)
        stock_data.fillna(method='ffill', inplace=True)
        # 打印数据的后5行
        n_features = len(stock_data.columns)
        # 获取DataFrame中的数据,形式为数组array形式
        values = stock_data.values
        # 确保所有数据为float类型
        values = values.astype('float32')
        # 特征的归一化处理
        scaler = MinMaxScaler(feature_range=(0, 1))
        # 数据一起处理再分训练集、测试集
        scaled = scaler.fit_transform(values)
        row = len(scaled)
        reframed = series_to_supervised(scaled, delay, 1)
        # 把数据分为训练集和测试集
        values = reframed.values
        train_end = int(np.floor(start_rate * row))
        test_start = train_end
        train = values[:train_end, :]
        test = values[test_start:, :]
        # 把数据分为输入和输出
        n_obs = delay * n_features
        # 分离特征集和标签
        train_X, train_y = train[:, :n_obs], train[:, -n_predictions]
        test_X, test_y = test[:, :n_obs], test[:, -n_predictions]
    
        # 把输入重塑成3D格式 [样例, 时间步, 特征]
        train_X = train_X.reshape((train_X.shape[0], 1, train_X.shape[1]))
        test_X = test_X.reshape((test_X.shape[0], 1, test_X.shape[1]))
        # 转化为三维数据,reshape input to be 3D [samples, timesteps, features]
        train_X = train_X.reshape((train_X.shape[0], delay, n_features))
        test_X = test_X.reshape((test_X.shape[0], delay, n_features))
        return train_X, train_y, test_X, test_y, scaler
    
    
    # 搭建LSTM模型
    train_X, train_y, test_X, test_y, scaler = generator()
    model = Sequential()
    model.add(LSTM(20, input_shape=(train_X.shape[1], train_X.shape[2]), return_sequences=True))
    model.add(LSTM(units=20))
    model.add(Dropout(0.5))
    model.add(Dense(1, activation='relu'))
    model.compile(loss='mean_squared_error', optimizer='adam')  # fit network  'mean_squared_error''mae'
    history = model.fit(train_X, train_y, epochs=500, batch_size=100, validation_data=(test_X, test_y), verbose=2,
                        shuffle=False)
    model.save('c:\python\model\model')
    # 绘制损失图
    plt.plot(history.history['loss'], label='train')
    plt.plot(history.history['val_loss'], label='test')
    plt.title('LSTM_000001.SZ', fontsize='12')
    plt.ylabel('loss', fontsize='10')
    plt.xlabel('epoch', fontsize='10')
    plt.legend()
    plt.show()
    
    print("训练完成,开始预测……")
    model = tf.keras.models.load_model('c:\python\model\model')
    # 模型预测收益率
    y_predict = model.predict(test_X)
    n_features = test_X.shape[2]
    # model.save(SAVE_PATH + 'model')
    test_X = test_X.reshape((test_X.shape[0], test_X.shape[1] * test_X.shape[2]))
    
    # 将预测结果按比例反归一化
    inv_y_test = concatenate((test_X[:, -n_features:-1], y_predict), axis=1)
    inv_y_test = scaler.inverse_transform(inv_y_test)
    inv_y_predict = inv_y_test[:, -1]
    
    # invert scaling for actual
    # #将真实结果按比例反归一化
    test_y = test_y.reshape((len(test_y), 1))
    inv_y_train = concatenate((test_X[:, -n_features:-1], test_y), axis=1)
    inv_y_train = scaler.inverse_transform(inv_y_train)
    inv_y = inv_y_train[:, -1]
    print('反归一化后的预测结果:', inv_y_predict)
    print('反归一化后的真实结果:', inv_y)
    
    # 写入文件
    df = pd.DataFrame()
    df['e'] = inv_y
    df['pe'] = inv_y_predict
    df.to_csv("c:\python\predict_result.csv")
    # 绘图
    '''
    inv_y=inv_y[delay:,]
    #inv_y=inv_y[:-delay,]
    for i in range(delay):
        #inv_y=np.concatenate((inv_y,inv_y[-1:,]) , axis=0)
        inv_y = np.concatenate((inv_y[0:1, ],inv_y), axis=0)
    '''
    plt.plot(inv_y, color='red', label='Original')
    plt.plot(inv_y_predict, color='green', label='Predict')
    plt.xlabel('the number of test data')
    plt.ylabel('5dayearn')
    plt.title('predict')
    plt.legend()
    plt.show()
    
    # 回归评价指标
    # calculate MSE 均方误差
    mse = mean_squared_error(inv_y, inv_y_predict)
    # calculate RMSE 均方根误差
    rmse = sqrt(mean_squared_error(inv_y, inv_y_predict))
    # calculate MAE 平均绝对误差
    mae = mean_absolute_error(inv_y, inv_y_predict)
    # calculate R square
    r_square = r2_score(inv_y, inv_y_predict)
    print('均方误差(mse): %.6f' % mse)
    print('均方根误差(rmse): %.6f' % rmse)
    print('平均绝对误差(mae): %.6f' % mae)
    print('R_square: %.6f' % r_square)
    

    数据质量分析如下:
    均方误差(mse): 0.673632
    均方根误差(rmse): 0.820751
    平均绝对误差(mae): 0.770078
    R_square: 0.067422

    代码生成5日数据预测和实际值对比图如下图所示:

    实际数据与预测数据对比图

    展开全文
  • 提到LSTM,我们就应该想到RNN,LSTM是RNN的一种改进,是RNN的变种。比如前几篇文章中讲的Mnist数据集分类,都是一张图片一张图片的输入,然后进行分类,这仅仅是对于图像来说,那么,对于语音或一串文字来说怎么做?...

    提到LSTM,我们就应该想到RNN,LSTM是RNN的一种改进,是RNN的变种。比如前几篇文章中讲的Mnist数据集分类,都是一张图片一张图片的输入,然后进行分类,这仅仅是对于图像来说,那么,对于语音或一串文字来说怎么做?这个就需要网络具有记忆的功能,RNN和LSTM都有这种功能。

    如果需要对语音或文字进行处理,就需要把网络看成是一个连续的整体,我们可以对网络加上一个反馈回路,如下图等号左边的图:

    在这里插入图片描述
    这个反馈回路会把上一次的输出信息作为下一次的输入信息来处理。如果是一段文字,我们把这段文字分成一个一个的词,然后一个一个的输入进LSTM网络中,比如,将第一个词输入进X0,得到一个结果h0,将第二个词输入h1,然后综合上一步的结果h0,输出h1,以此类推,知道这段文字全部输入网络中…

    其实LSTM和BP神经网络差不多,但是BP网络会有一个梯度消失的问题。如下图中中间隐藏层的消失问题:

    在这里插入图片描述
    那么可能会有人想到用y=x这样的线性激活函数激活,这样梯度就不会消失了,但是它也会产生一些问题,它会记住很久以前的信息,包括主要特征和非主要特征,这些它全部都记住了,根本无法知道主要特征是什么,这个网络也就是废的。那么这样的做法很明显是错的,正确的做法就是有选择性的记忆,只记忆主要特征信息,这样就诞生了LSTM网络:
    在这里插入图片描述
    在LSTM中的隐层单元中,我们不叫神经元,我们叫它Block,如上图所示。上图中是什么意思呢?首先我们来这里:
    在这里插入图片描述
    输入的信息从山上图中输入,经过“Input Gate”进行判断是否是主要信息,如果不是主要信息,“Input Gate”的值就是0,通过与输入信息相乘,将非主要特征变为0。如果是主要特征,“Input Gate”放行,来到“Cell”部分:
    在这里插入图片描述
    “Cell”部分有一个“Forget Gate”,它可以选择性的忘记(忽略)非主要特征,再进一步的下采样,提取主要特征。一旦结果满意之后,到达这一层:
    在这里插入图片描述
    如果信息通过了“Output Gate”,则可以将信息输出,否则,将会在“Cell”部分循环,直至能够被“Output Gate”接受。

    下面就是整个LSTM的网络示意图:
    在这里插入图片描述
    比如说下图中的Time 1有一个信号传入隐层,在隐层中可以不经过衰减往后传递信号,隐层中“-”的意思表示“不让它输出”,一直进行下去,直到输入结束。

    在这里插入图片描述

    下面进行代码实现(mnist数据集训练及测试):

    import tensorflow as tf
    from tensorflow.examples.tutorials.mnist import input_data
    
    
    mnist = input_data.read_data_sets("mnist/", one_hot=True)
    
    
    lstm_size=200  # 隐层100个block
    n_class=10  # 10个分类
    batch_size=128  #每次50个训练样本
    n_inputs = 28 # 输入一行,一行有28个数据
    max_time = 28 # 一共28行
    
    x=tf.placeholder(shape=[None,784],dtype=tf.float32)
    x_image=tf.reshape(x,shape=[-1,max_time,n_inputs])
    y=tf.placeholder(shape=[None,n_class],dtype=tf.float32)
    
    # 初始化权值
    w=tf.Variable(tf.truncated_normal(shape=[lstm_size,n_class],stddev=0.1),dtype=tf.float32)
    # 初始化偏执值
    b=tf.Variable(tf.constant(0.1,shape=[10]),dtype=tf.float32)
    
    lstm_cell=tf.nn.rnn_cell.BasicLSTMCell(lstm_size)  #定义LSTM基本Cell,这里相当于有100个Cell
    outputs,final_state=tf.nn.dynamic_rnn(lstm_cell,x_image,dtype=tf.float32) #返回两个值
    # outputs  default(False) outputs=[batch_size,max_time,cell.output_size]
    # outputs  (True) outputs=[max_time,batch_size,cell.output_size]
    #--------------------------------
    # final_state=[state,batch_size,cell.state_size]
    # final_state[0]是cell state
    # final_state[1]是hidden state
    #------------------------------
    out1=tf.add(tf.matmul(final_state[1],w),b)
    y_=tf.nn.softmax(out1)  # 预测值
    
    loss=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=y_))  # 平均损失
    step=tf.train.AdamOptimizer(1e-4).minimize(loss) #自适应梯度下降
    acc_mat=tf.equal(tf.argmax(y,1),tf.argmax(y_,1))
    acc=tf.reduce_mean(tf.cast(acc_mat,dtype=tf.float32))  # 准确率
    
    init=tf.global_variables_initializer()
    with tf.Session() as sess:
        sess.run(init)
        count=0
        for i in range(10000):
            batch_xs,batch_ys=mnist.train.next_batch(batch_size)
            sess.run(step,feed_dict={x:batch_xs,y:batch_ys})
            if (i+1)%100==0:
                curr_acc,curr_loss=sess.run([acc,loss],feed_dict={x:mnist.test.images,y:mnist.test.labels})
                print("第"+str(count+1)+"次","当前测试集准确率:",curr_acc,"损失值:",curr_loss)
                count+=1
    

    每训练100次就进行一次测试,得到的结果如下所示:
    在这里插入图片描述
    最终结果能够达到接近97%,这个网络代码很少,本身没有什么可以优化的地方,可以调调参数,看看准确值会不会往上走。

    展开全文
  • 基础原理

    2019-07-15 13:54:41
    2)RNN系列,掌握RNN、LSTM和GRU的内部结构,RNN产生梯度消失的原因,LSTM如何解决,GRU对LSTM改进。 3)Word2vec工具,怎么训练词向量,skip-gram和cbow,可以参考一下:一篇通俗易懂的word2vec(也可能并不通俗...

    1)CNN原理,如何用在文本上,在什么情况下适合用CNN,在什么情况下用LSTM

    2)RNN系列,掌握RNN、LSTM和GRU的内部结构,RNN产生梯度消失的原因,LSTM如何解决,GRU对LSTM的改进。

    3)Word2vec工具,怎么训练词向量,skip-gram和cbow,可以参考一下:一篇通俗易懂的word2vec(也可能并不通俗易懂)

    4)Attention机制,比较常见的方法,可以参考一下:Attention用于NLP的一些小结

    5)NLP基础任务,比如分词算法(序列标注任务),分类算法

     

    1、CNN原理,如何用在文本上,在什么情况下适合用CNN,在什么情况下用LSTM

    给CNN最适合的任务就是分类,比如Sentiment Analysis, Spam Detection, 或者Topic Categorization. 卷积和Pooling算子会丢失一些局部的位置信息,从而使得句子标签变成了Part of Speech标签或者Entity提取变得更加困难对于纯粹的CNN框架。

     

    2、深层网络和浅层网络相比有什么优势呢?

    简单来说深层网络能够表达力更强。事实上,一个仅有一个隐藏层的神经网络就能拟合任何一个函数,但是它需要很多很多的神经元。而深层网络用少得多的神经元就能拟合同样的函数。也就是为了拟合一个函数,要么使用一个浅而宽的网络,要么使用一个深而窄的网络。而后者往往更节约资源。

    展开全文
  • 有大佬可以帮忙指点一下要怎么改进吗? <code>import tensorflow as tf from keras.models import Model from keras.layers.core import Dense, Dropout from keras.layers.convolutional import ...
  • BPCLSTM

    2020-05-23 14:07:33
    Classic LSTM在RNN 卷积神经网络上的改进,网络结构如图所示: Classic Lstm 的定义如下: 分别表示输入门,遗忘门、输出门,是sigmoid 函数,表示bias ,是在t时刻的输入、激活状态、隐藏状态。W表示权重...

    传统LSTM

    Classic LSTM在RNN 卷积神经网络上的改进,网络结构如图所示:

              

                

    Classic Lstm 的定义如下:

    i_t, f_t, o_t分别表示输入门,遗忘门、输出门,\sigma()是sigmoid 函数,b_i, b_f, b_c, b_o表示bias ,是在t时刻的输入、激活状态、隐藏状态。W表示权重矩阵。比如W_{hf} 控制遗忘门怎么从隐藏状态获取值。

    C-LSTM (convlstm)

           CLSTM 【1】是最近生成的LSTM,主要用于输入是图像,用卷积操作替换向量乘法。LSTM处理序列问题,1维数据,CLSTM在对于图像序列的处理中,有优势,比如图像序列的预测以及编码解码框架。

                        

    都是3D tensors。定义如下:将传统的LSTM 中的向量乘积用卷积操作替代。

                  

                 

    CLSTMCell代表CLSTM序列中的一个节点,只产生一个时刻的输出。 hidden_channels 为隐藏层数目,相当于CNN中卷积层的卷积核数目。

    import torch
    import torch.nn as nn
    from torch.autograd import Variable
         
    # Batch x NumChannels x Height x Width
    # UNET --> BatchSize x 1 (3?) x 240 x 240
    # BDCLSTM --> BatchSize x 64 x 240 x240
         
    ''' Class CLSTMCell.
        This represents a single node in a CLSTM series.
        It produces just one time (spatial) step output.
    '''
         
         
    class CLSTMCell(nn.Module):
         
        # Constructor
        def __init__(self, input_channels, hidden_channels,
                     kernel_size, bias=True):
            super(CLSTMCell, self).__init__()
         
            assert hidden_channels % 2 == 0
         
            self.input_channels = input_channels
            self.hidden_channels = hidden_channels
            self.bias = bias
            self.kernel_size = kernel_size
            self.num_features = 4
         
            self.padding = (kernel_size - 1) // 2
            self.conv = nn.Conv2d(self.input_channels + self.hidden_channels,
                                  self.num_features * self.hidden_channels,
                                  self.kernel_size,
                                  1,
                                  self.padding)
         
        # Forward propogation formulation
        def forward(self, x, h, c):
            # print('x: ', x.type)
            # print('h: ', h.type)
            combined = torch.cat((x, h), dim=1)
            A = self.conv(combined)
         
            # NOTE: A? = xz * Wx? + hz-1 * Wh? + b? where * is convolution
            (Ai, Af, Ao, Ag) = torch.split(A,
                                           A.size()[1] // self.num_features,
                                           dim=1)
             
            i = torch.sigmoid(Ai)     # input gate
            f = torch.sigmoid(Af)     # forget gate
            o = torch.sigmoid(Ao)     # output gate
            g = torch.tanh(Ag)
         
            c = c * f + i * g           # cell activation state
            h = o * torch.tanh(c)     # cell hidden state
         
            return h, c
         
        @staticmethod
        def init_hidden(batch_size, hidden_c, shape):
            try:
                return(Variable(torch.zeros(batch_size,
                                hidden_c,
                                shape[0],
                                shape[1])).cuda(),
                   Variable(torch.zeros(batch_size,
                                        hidden_c,
                                        shape[0],
                                        shape[1])).cuda())
            except:
                return(Variable(torch.zeros(batch_size,
                                hidden_c,
                                shape[0],
                                shape[1])),
                          Variable(torch.zeros(batch_size,
                                        hidden_c,
                                        shape[0],
                                        shape[1])))

    CLSTM 为多个CLSTMCell的组合。

    ''' Class CLSTM.
        This represents a series of CLSTM nodes (one direction)
    '''
         
         
    class CLSTM(nn.Module):
        # Constructor
        def __init__(self, input_channels=64, hidden_channels=[64],
                     kernel_size=5, bias=True):
            super(CLSTM, self).__init__()
         
            # store stuff
            self.input_channels = [input_channels] + hidden_channels
            self.hidden_channels = hidden_channels
            self.kernel_size = kernel_size
            self.num_layers = len(hidden_channels)
         
            self.bias = bias
            self.all_layers = []
         
            # create a node for each layer in the CLSTM
            for layer in range(self.num_layers):
                name = 'cell{}'.format(layer)
                cell = CLSTMCell(self.input_channels[layer],
                                 self.hidden_channels[layer],
                                 self.kernel_size,
                                 self.bias)
                setattr(self, name, cell)
                self.all_layers.append(cell)
         
        # Forward propogation
        # x --> BatchSize x NumSteps x NumChannels x Height x Width
        #       BatchSize x 2 x 64 x 240 x 240
        def forward(self, x):
            bsize, steps, _, height, width = x.size()
            internal_state = []
            outputs = []
            for step in range(steps):
                input = torch.squeeze(x[:, step, :, :, :], dim=1)
                for layer in range(self.num_layers):
                    # populate hidden states for all layers
                    if step == 0:
                       (h, c) = CLSTMCell.init_hidden(bsize,
                                                      self.hidden_channels[layer],
                                                      (height, width))
                       internal_state.append((h, c))
         
                    # do forward
                    name = 'cell{}'.format(layer)
                    (h, c) = internal_state[layer]
         
                    input, c = getattr(self, name)(
                            input, h, c)  # forward propogation call
                    internal_state[layer] = (input, c)
         
                outputs.append(input)
         
            #for i in range(len(outputs)):
            #    print(outputs[i].size())
            return outputs

    BPC-LSTM(Bi_Directional Conv-LSTM)

    BPC-LSTM【2】是在C-LSTM的扩展,C-LSTM作用在两个相反的方向,一个在Z{^{-}} 方向,一个在Z^{^{+}}方向,结合两层的上下文信息作为输出。

    A作为一个BPC-LSTM单元,在深层结构中,可以将其看作和CNN层相似的结构,组合成深层次结构。

    class BDCLSTM(nn.Module):
          # Constructor
          def __init__(self, input_channels=64, hidden_channels=[64],
                         kernel_size=5, bias=True, num_classes=2):
         
              super(BDCLSTM, self).__init__()
              self.forward_net = CLSTM(
                    input_channels, hidden_channels, kernel_size, bias)
              self.reverse_net = CLSTM(
                    input_channels, hidden_channels, kernel_size, bias)
              self.conv = nn.Conv2d(
                    2 * hidden_channels[-1], num_classes, kernel_size=1)
              self.soft = nn.Softmax2d()
         
          # Forward propogation
          # x --> BatchSize x NumChannels x Height x Width
          #       BatchSize x 64 x 240 x 240
          def forward(self, x1, x2, x3):
              x1 = torch.unsqueeze(x1, dim=1)
              x2 = torch.unsqueeze(x2, dim=1)
              x3 = torch.unsqueeze(x3, dim=1)
         
              xforward = torch.cat((x1, x2), dim=1)
              xreverse = torch.cat((x3, x2), dim=1)
         
              yforward = self.forward_net(xforward)
              yreverse = self.reverse_net(xreverse)
         
              # assumes y is BatchSize x NumClasses x 240 x 240
              # print(yforward[-1].type)
              ycat = torch.cat((yforward[-1], yreverse[-1]), dim=1)
              # print(ycat.size())
              y = self.conv(ycat)
              # print(y.type)
              y = self.soft(y)
              # print(y.type)
              return y

     

     

    展开全文
  • (*)激活函数改进?初始化方法卷积核为什么是奇数?怎么增大感受野?决策树怎么选择特征?LSTM介绍?(*)GAN损失函数?(*)为什么LSTM后面接CRF更好归一化方式?聚类算法,评价方法,优化算法激活函数如何引入非...
  • 因为我自己是比较希望做NLP方向的研究,之前简单回顾了一下基础的神经网络之后,接下来打算就从NLP的角度,来看看模型是怎么一步步改进发展的。 对于自然语言处理,首先想到的问题肯定是怎么把自然语言转化为向数字...
  • 3.比赛改进的话怎么改 4.LSTM的原理,RNN用于哪些数据 5.CNN用于哪些数据 6.哪些问题要问 云知声 30min 1.自我介绍 2.项目细节 3.如何判断最终项目的结果 4.YOLOv3详细介绍 5 有什么问题 南京积图 主要就是项目,聊...

空空如也

空空如也

1 2 3
收藏数 46
精华内容 18
关键字:

lstm怎么改进