Ejemplo n.º 1
0
def example_0():
    # learns to repeat simple sequence from random inputs
    np.random.seed(0)
    losses = []

    # parameters for input data dimension and lstm cell count
    mem_cell_ct = 100
    x_dim = 50
    lstm_param = LstmParam(mem_cell_ct, x_dim)
    lstm_net = LstmNetwork(lstm_param)
    y_list = [-0.5, 0.2, 0.1, -0.5]
    input_val_arr = [np.random.random(x_dim) for _ in y_list]

    for cur_iter in range(100):
        # aqui estamos passando pelos epochs
        print("iter", "%2s" % str(cur_iter), end=": ")
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])

        print("y_pred = [" + ", ".join([
            "% 2.5f" % lstm_net.lstm_node_list[ind].state.h[0]
            for ind in range(len(y_list))
        ]) + "]",
              end=", ")

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        losses.append(loss)
        print("loss:", "%.3e" % loss)
        lstm_param.apply_diff(lr=0.1)  # aqui se aplica o aprendizado
        lstm_net.x_list_clear()
    return losses
Ejemplo n.º 2
0
def example_0():
    mem_cell_ct = 100
    x_dim = 50
    concat_len = x_dim + mem_cell_ct
    lstm_param = LstmParam(mem_cell_ct, x_dim) 
    lstm_net = LstmNetwork(lstm_param)

    primes = Primes()
    x_list = []
    y_list = []
    for i in range(0, 10):
        sample = primes.get_sample(x_dim, 1, i)
        x = sample[0:x_dim]
        y = sample[x_dim:x_dim+1].tolist()[0]
        x_list.append(x)
        y_list.append(y)

    for cur_iter in range(10000):
        if cur_iter % 1000 == 0:
            print "y_list=", y_list
        for ind in range(len(y_list)):
            lstm_net.x_list_add(x_list[ind])
            if cur_iter % 1000 == 0:
                print "y_pred[%d] : %f" % (ind, lstm_net.lstm_node_list[ind].state.h[0])

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        if cur_iter % 1000 == 0:
            print "loss: ", loss
        lstm_param.apply_diff(lr=0.01)
        lstm_net.x_list_clear()
Ejemplo n.º 3
0
def example_0():
    # learns to repeat simple sequence from random inputs
    np.random.seed(0)

    # parameters for input data dimension and lstm cell count
    #指定神经元个数为100
    mem_cell_ct = 100
    #制定输入样本的特征维度数量 输入4个样本,每个样本是1*50的维度
    x_dim = 50
    #用神经元个数和样本维度数初始化LSTM
    lstm_param = LstmParam(mem_cell_ct, x_dim)
    #初始化网络
    lstm_net = LstmNetwork(lstm_param)
    #标签、目标输出
    y_list = [-0.5, 0.2, 0.1, -0.5]
    #生成输入数据
    input_val_arr = [np.random.random(x_dim) for _ in y_list]
    #for _ in y_list:
    #input_val_arr.append(np.random.random(x_dim))
    for cur_iter in range(1000):
        print("iter", "%2s" % str(cur_iter), end=": ")
        for ind in range(len(y_list)):  #[0,1,2,3]
            lstm_net.x_list_add(input_val_arr[ind])

        print("y_pred = [" + ", ".join([
            "% 2.5f" % lstm_net.lstm_node_list[ind].state.h[0]
            for ind in range(len(y_list))
        ]) + "]",
              end=", ")

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        print("loss:", "%.3e" % loss)
        lstm_param.apply_diff(lr=0.1)
        lstm_net.x_list_clear()
Ejemplo n.º 4
0
def example_0():
    # learns to repeat simple sequence from random inputs
    np.random.seed(0)

    # parameters for input data dimension and lstm cell count 
    mem_cell_ct = 100
    x_dim = 50
    concat_len = x_dim + mem_cell_ct
    lstm_param = LstmParam(mem_cell_ct, x_dim) 
    lstm_net = LstmNetwork(lstm_param)
    y_list = [-0.5,0.2,0.1, -0.5]
    input_val_arr = [np.random.random(x_dim) for _ in y_list]

    for cur_iter in range(100):
        print "cur iter: ", cur_iter
        print "input_val_arr=", input_val_arr
        print "y_list=", y_list
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])
            print "y_pred[%d] : %f" % (ind, lstm_net.lstm_node_list[ind].state.h[0])

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        print "loss: ", loss
        lstm_param.apply_diff(lr=0.1)
        lstm_net.x_list_clear()
Ejemplo n.º 5
0
def example_0():
    # learns to repeat simple sequence from random inputs
    np.random.seed(0)
    x1=[float(i)/700 for i in dataAnalyze.testData().pop()]
    print x1
    # parameters for input data dimension and lstm cell count 
    mem_cell_ct = 10
    #x_dim = 50
    x_dim=len(x1)/2
    concat_len = x_dim + mem_cell_ct 
    lstm_param = LstmParam(mem_cell_ct, x_dim) 
    lstm_net = LstmNetwork(lstm_param)
    y_list = [139/500,455/500]
    input_val_arr=[x1[::2],x1[1::2]]
    #input_val_arr = [np.random.random(x_dim) for _ in y_list]
 #   input_val_arr = [np.random.random(x_dim) for _ in range(4)]
 #   input_val_arr = [np.random.uniform(-0.1,0.1,x_dim) for _ in y_list]



    for cur_iter in range(200):
        print "cur iter: ", cur_iter
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])

            print "y_pred[%d] : %f" % (ind, lstm_net.lstm_node_list[ind].state.h[0])

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        print "loss: ", loss
        lstm_param.apply_diff(lr=0.1)
        lstm_net.x_list_clear()
Ejemplo n.º 6
0
def example_1():
    # learns to repeat simple sequence from random inputs
    np.random.seed(0)
    
    data_path = 'F:\研究生\无人机项目\二维条件下计算轨迹和时间//data_t_10.mat'
    data_xy,data_v_theta = load_data(data_path)
    
    # parameters for input data dimension and lstm cell count
    mem_cell_ct = 100
    x_dim = 2
    lstm_param = LstmParam(mem_cell_ct, x_dim)
    lstm_net = LstmNetwork(lstm_param)
    y_list = data_v_theta[0,:]

    #input_val_arr = [data.append(data_xy[:,i]) for i in range(36000)]
    data = []
    for i in range(36000):
        data.append(data_xy[:,i])    
    input_val_arr  = data

    for cur_iter in range(100):
        print("iter", "%2s" % str(cur_iter), end=": ")
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])

        print("y_pred = [" +
              ", ".join(["% 2.5f" % lstm_net.lstm_node_list[ind].state.h[0] for ind in range(len(y_list))]) +
              "]", end=", ")

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        print("loss:", "%.3e" % loss)
        lstm_param.apply_diff(lr=0.1)
        lstm_net.x_list_clear()
Ejemplo n.º 7
0
def example_0():
    # learns to repeat simple sequence from random inputs
    np.random.seed(0)

    # parameters for input data dimension and lstm cell count
    mem_cell_ct = 100  #100个lstm节点
    x_dim = 50  #输入值的维度
    concat_len = x_dim + mem_cell_ct  #150
    lstm_param = LstmParam(mem_cell_ct, x_dim)  #
    lstm_net = LstmNetwork(lstm_param)
    y_list = [-0.5, 0.2, 0.1, -0.5]  #4
    input_val_arr = [np.random.random(x_dim)
                     for _ in y_list]  #产生4个x_dim维的向量,每个向量维度为:50
    #即为每个向量x训练到y的模型

    for cur_iter in range(100):  #训练100次
        print "cur iter: ", cur_iter
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])
            print "y_pred[%d] : %f" % (ind,
                                       lstm_net.lstm_node_list[ind].state.h[0])

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        print "loss: ", loss
        lstm_param.apply_diff(lr=0.1)
        lstm_net.x_list_clear()
Ejemplo n.º 8
0
def example_0():
    # learns to repeat simple sequence from random inputs
    np.random.seed(0)
    x1 = [float(i) / 700 for i in dataAnalyze.testData().pop()]
    print x1
    # parameters for input data dimension and lstm cell count
    mem_cell_ct = 10
    #x_dim = 50
    x_dim = len(x1) / 2
    concat_len = x_dim + mem_cell_ct
    lstm_param = LstmParam(mem_cell_ct, x_dim)
    lstm_net = LstmNetwork(lstm_param)
    y_list = [139 / 500, 455 / 500]
    input_val_arr = [x1[::2], x1[1::2]]
    #input_val_arr = [np.random.random(x_dim) for _ in y_list]
    #   input_val_arr = [np.random.random(x_dim) for _ in range(4)]
    #   input_val_arr = [np.random.uniform(-0.1,0.1,x_dim) for _ in y_list]

    for cur_iter in range(200):
        print "cur iter: ", cur_iter
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])

            print "y_pred[%d] : %f" % (ind,
                                       lstm_net.lstm_node_list[ind].state.h[0])

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        print "loss: ", loss
        lstm_param.apply_diff(lr=0.1)
        lstm_net.x_list_clear()
Ejemplo n.º 9
0
def example_0():
    # learns to repeat simple sequence from random inputs
    np.random.seed(0)

    # parameters for input data dimension and lstm cell count
    mem_cell_ct = 100
    x_dim = 50
    lstm_param = LstmParam(mem_cell_ct, x_dim)
    lstm_net = LstmNetwork(lstm_param)
    y_list = [-0.5, 0.2, 0.1, -0.5] #这是1个样本的label,分别为每个输入word embedding的打分
    # 为每个y,生成一个x输入向量,x样本序列的长度为4,embedding维度为50
    # 类比例子,可以看成对序列中的每个向量进行pos/neg打分
    input_val_arr = [np.random.random(x_dim) for _ in y_list] # list of ndarray(dim=50), list长度为4
    print("input_val_arr:", input_val_arr)

    for cur_iter in range(210):
        print("iter", "%2s" % str(cur_iter), end=": ")
        for ind in range(len(y_list)):
            # 将每个样本的x放到网络中
            lstm_net.x_list_add(input_val_arr[ind])

        print("y_pred = [" +
              ", ".join(["% 2.5f" % lstm_net.lstm_node_list[ind].state.h[0] for ind in range(len(y_list))]) +
              "]", end=", ")
        # 将label放到网络中
        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        print("loss:", "%.3e" % loss)
        lstm_param.apply_diff(lr=0.1) # 计算网络的梯度
        lstm_net.x_list_clear() # 每次迭代时,需要将x清空
Ejemplo n.º 10
0
def example_0():
    # learns to repeat simple sequence from random inputs
    np.random.seed(0)
    data = psg.load_data(FILE)
    X, Y = psg.create_dataset(data, 7)
    # parameters for input data dimension and lstm cell count
    mem_cell_ct = 14
    x_dim = 7
    lstm_param = LstmParam(mem_cell_ct, x_dim)
    lstm_net = LstmNetwork(lstm_param)
    y_list = Y[:20]
    print(y_list)
    input_val_arr = X[:20]

    # y_list = [-0.5, 0.2, 0.1, -0.5]
    # input_val_arr = [np.random.random(x_dim) for _ in y_list] # a list of array which shape is (x_dim,)

    for cur_iter in range(10000):
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])
        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        lstm_param.apply_diff(lr=0.1)
        lstm_net.x_list_clear()

        if cur_iter % 500 == 0:
            print("iter", "%2s" % str(cur_iter), end=": ")
            print("y_pred = [" + ", ".join([
                "% 2.5f" % lstm_net.lstm_node_list[ind].state.h[0]
                for ind in range(len(y_list))
            ]) + "]",
                  end=", ")
            print("loss:", "%.3e" % loss)
Ejemplo n.º 11
0
def example_0():
    mem_cell_ct = 100
    x_dim = 50
    concat_len = x_dim + mem_cell_ct
    lstm_param = LstmParam(mem_cell_ct, x_dim)
    lstm_net = LstmNetwork(lstm_param)

    primes = Primes()
    x_list = []
    y_list = []
    for i in range(0, 10):
        sample = primes.get_sample(x_dim, 1, i)
        x = sample[0:x_dim]
        y = sample[x_dim:x_dim + 1].tolist()[0]
        x_list.append(x)
        y_list.append(y)

    for cur_iter in range(10000):
        if cur_iter % 1000 == 0:
            print("y_list=", y_list)
        for ind in range(len(y_list)):
            lstm_net.x_list_add(x_list[ind])
            if cur_iter % 1000 == 0:
                print("y_pred[%d] : %f" %
                      (ind, lstm_net.lstm_node_list[ind].state.h[0]))

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        if cur_iter % 1000 == 0:
            print("loss: ", loss)
        lstm_param.apply_diff(lr=0.01)
        lstm_net.x_list_clear()
Ejemplo n.º 12
0
def example_0():  #lstm
    # learns to repeat simple sequence from random inputs
    # 从随机输入重复简单的序列学习
    np.random.seed(0)

    # parameters for input data dimension and lstm cell count
    # 输入数据维度和lstm单元数量的参数
    mem_cell_ct = 100  # mem_cell_ct是lstm的神经元数目
    x_dim = 50  # x_dim是输入数据的维度
    lstm_param = LstmParam(mem_cell_ct, x_dim)
    lstm_net = LstmNetwork(lstm_param)
    #y_list = [-0.5, 0.2, 0.1, -0.5]     #此 代码 其是通过自己实现 lstm 网络来逼近一个序列,y_list = [-0.5, 0.2, 0.1, -0.5]                        #
    y_list = [-0.5, 0, -0.5]
    input_val_arr = [np.random.random(x_dim) for _ in y_list]  # 输入

    #print(input_val_arr)
    for cur_iter in range(100000):
        print("iter", "%2s" % str(cur_iter), end=": ")
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])

        print("y_pred = [" + ", ".join([
            "% 2.5f" % lstm_net.lstm_node_list[ind].state.h[0]
            for ind in range(len(y_list))
        ]) + "]",
              end=", ")

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        print("loss:", "%.3e" % loss)
        lstm_param.apply_diff(lr=0.1)
        lstm_net.x_list_clear()
Ejemplo n.º 13
0
def example_0():
    # learns to repeat simple sequence from random inputs
    np.random.seed(0)

    # parameters for input data dimension and lstm cell count
    mem_cell_ct = 100
    x_dim = 50
    lstm_param = LstmParam(mem_cell_ct, x_dim)
    lstm_net = LstmNetwork(lstm_param)
    y_list = [-0.5, 0.2, 0.1, -0.5]
    input_val_arr = [np.random.random(x_dim) for _ in y_list]

    for cur_iter in range(100):
        print("iter", "%2s" % str(cur_iter))
        for ind in range(len(y_list)):
            print("x" + str(input_val_arr[ind]))
            lstm_net.x_list_add(input_val_arr[ind])

        print("y_pred = [" + ", ".join([
            "% 2.5f" % lstm_net.lstm_node_list[ind].state.h[0]
            for ind in range(len(y_list))
        ]) + "]")

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        print("loss:", "%.3e" % loss)
        lstm_param.apply_diff(lr=0.1)
        lstm_net.x_list_clear()
Ejemplo n.º 14
0
def example_0():
    # learns to repeat simple sequence from random inputs
    np.random.seed(0)

    # parameters for input data dimension and lstm cell count 
    mem_cell_ct = 100
    x_dim = 50
    concat_len = x_dim + mem_cell_ct
    lstm_param = LstmParam(mem_cell_ct, x_dim) 
    lstm_net = LstmNetwork(lstm_param)
    
    # predict number
    y_list = [-0.5, 0.2, 0.1, -0.4]
    input_val_arr = [np.random.random(x_dim) for _ in y_list] # 一个list,包含随机生成的4个 array(50)
    #  print(input_val_arr)
    
    # 四个数据为一组,循环100遍
    for cur_iter in range(100):
        print ("cur_iter : ", cur_iter)
        
        # 四个数据为一组,对应y值。进行参数更新
        for ind in range(len(y_list)):
            # 前向传播
            lstm_net.x_list_add(input_val_arr[ind])
            print ("y_pred[%d] : %f" % (ind, lstm_net.lstm_node_list[ind].state.h[0]),lstm_net.lstm_node_list[ind].state.h.shape)
            print(lstm_net.lstm_node_list[ind].state.h)

        # 反向传播
        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        # print ("loss: "), loss
        print ("loss: %f" % loss)
        
        # update the parameters
        lstm_param.apply_diff(lr=0.1)
        lstm_net.x_list_clear()
Ejemplo n.º 15
0
def example_0():
    # learns to repeat simple sequence from random inputs
    np.random.seed(0)

    # parameters for input data dimension and lstm cell count
    mem_cell_ct = 100
    x_dim = 50
    lstm_param = LstmParam(mem_cell_ct, x_dim)
    lstm_net = LstmNetwork(lstm_param)
    y_list = [-0.5, 0.2, 0.1, -0.5]
    input_val_arr = [np.random.random(x_dim) for _ in y_list]
    # print("input_val_arr", input_val_arr)
    # json_dump = json.dumps({'iva': input_val_arr}, cls=NumpyEncoder)
    # f = open('wg.txt', 'w')
    # json.dump(json_dump, f)
    # f.close()

    for cur_iter in range(100):
        print("iter", "%2s" % str(cur_iter), end=": ")
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])

        # print("ind of: ", ind)
        # print("node_state_h", lstm_net.lstm_node_list[ind].state.h)
        print("y_pred = [" + ", ".join([
            "% 2.5f" % lstm_net.lstm_node_list[ind].state.h[0]
            for ind in range(len(y_list))
        ]) + "]",
              end=", ")

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        print("loss:", "%.3e" % loss)
        lstm_param.apply_diff(lr=0.1)
        lstm_net.x_list_clear()
def example_0():

    np.random.seed(0)
    mem_cell_ct = 100

    x_dim = 1
    lstm_param = LstmParam(mem_cell_ct, x_dim)
    lstm_net = LstmNetwork(lstm_param)

    """
    y_list = [-0.5, 0.2, 0.1, -0.5]  # 五步
    input_val_arr = [np.random.random(x_dim) for _ in y_list]

    for i in range(len(input_val_arr)):
        print "input_val_arr = ", input_val_arr[i]
    """
    input_val_arr = [
        [1, 2],
        [2, 3],
        [3, 4]
    ]

    pre_x = [
        [3, 4]
    ]

    y_list = [0.03, 0.05, 0.07]
    x = np.arange(-1, 1, 0.01)
    xa = []
    for i in range(len(x)):
        xa.append([x[i]])
    # y = 2 * np.sin(x * 2.3) + 0.5 * x ** 3
    # y1 = y + 0.5 * (np.random.rand(len(x)) - 0.5)
    y = ((x * x - 1) ** 3 + 1) * (np.cos(x * 2) + 0.6 * np.sin(x * 1.3))
    y_list = y + (np.random.rand(len(x)) - 0.5)
    # print "input_val_arr = ", input_val_arr

    for cur_iter in range(len(x)):
        for ind in range(len(y_list)):
            lstm_net.x_list_add(xa[ind])

        y_pred = [0] * len(y_list)

        for i in range(len(y_list)):
            y_pred[i] = lstm_net.lstm_node_list[i].state.h[0]

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        # print("loss:", "%.3e" % loss)

        lstm_param.apply_diff(lr=0.1)  # 更新权重
        lstm_net.x_list_clear()

    plt.plot(xa, y_list)
    plt.plot(xa, y_pred)
    plt.show()
    print "loss = ", loss
    print "y_pred = ", y_pred
def test(data_x, day_flaovr_num):
    np.random.seed(0)
    mem_cell_ct = 100
    x_dim = 7  # 7天一个维度

    lstm_param = LstmParam(mem_cell_ct, x_dim)
    lstm_net = LstmNetwork(lstm_param)

    """
    input = []
    y_list = []
    # 处理数,将数据处理成  7天一段,逐天滚动
    for i in range(len(data_x) - 7):
        input.append(data_x[i: i+7])
        # y_list.append(day_flaovr_num[i + 7][0])

    for i in range(len(data_x) - 7):
        y_list.append(day_flaovr_num[i + 7])

    # y_list = [-0.5, 0.2, 0.1, -0.5]  # 五步
    # input_val_arr = [np.random.random(x_dim) for _ in y_list]

    for i in range(len(input)):
        print "input_val_arr = ", input[i]

    for i in range(len(y_list)):
        print "y_list =", y_list[i]

    print "len(input) = ", len(input)
    print "len(y_list) = ", len(y_list)
    
"""

    input_val_arr = [
        [1, 2, 3, 4, 5, 6, 7],
        [2, 3, 4, 5, 6, 7, 8]
        [3, 4, 5, 6, 7, 8, 9],
    ]
    y_list = [1, 2, 3]
    for cur_iter in range(100):
        # print("iter", "%2s" % str(cur_iter), end=": ")
        print "str(cur_iter) = ", str(cur_iter)
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])

        # print("y_pred = [" +
        #       ", ".join(["% 2.5f" % lstm_net.lstm_node_list[ind].state.h[0] for ind in range(len(y_list))]) +
        #       "]", end=", ")
        for i in range(len(y_list)):
            print "y_pred = ", lstm_net.lstm_node_list[i].state.h[0]

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        # print("loss:", "%.3e" % loss)
        print "loss = ", loss
        lstm_param.apply_diff(lr=0.1)  # 更新权重
        lstm_net.x_list_clear()
Ejemplo n.º 18
0
def example_1():  #vavelet
    filename = 'data.txt'  #txt文件和当前脚本在同一目录下,所以不用写具体路径
    data = []
    with open(filename, 'r') as file_to_read:
        while True:
            lines = file_to_read.readline()  # 整行读取数据
            if not lines:
                break
                pass
            # 将整行数据分割处理,如果分割符是空格,括号里就不用传入参数,如果是逗号, 则传入‘,'字符。
            p_tmp = lines.split()
            data.append(p_tmp[0])  # 添加新读取的数据
            pass

    x = np.arange(len(data))
    y = data
    # 连续小波变换
    coef, freqs = pywt.cwt(y, np.arange(1, 128), 'gaus1')
    # 时频(尺度)图
    #plt.matshow( coef )
    # 频率
    #plt.plot(freqs)

    # learns to repeat simple sequence from random inputs
    # 从随机输入重复简单的序列学习
    np.random.seed(0)

    # parameters for input data dimension and lstm cell count
    # 输入数据维度和lstm单元数量的参数
    mem_cell_ct = 100  # mem_cell_ct是lstm的神经元数目
    x_dim = 50  # x_dim是输入数据的维度
    lstm_param = LstmParam(mem_cell_ct, x_dim)
    lstm_net = LstmNetwork(lstm_param)
    #y_list = [-0.5, 0.2, 0.1, -0.5]     #此 代码 其是通过自己实现 lstm 网络来逼近一个序列,y_list = [-0.5, 0.2, 0.1, -0.5]                        #
    y_list = [-0.5, 0, -0.5]
    input_val_arr = [np.random.random(x_dim) for _ in y_list]  # 输入

    #print(input_val_arr)
    for cur_iter in range(1000):
        print("iter", "%2s" % str(cur_iter), end=": ")
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])

        print("y_pred = [" + ", ".join([
            "% 2.5f" % lstm_net.lstm_node_list[ind].state.h[0]
            for ind in range(len(y_list))
        ]) + "]",
              end=", ")

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        print("loss:", "%.3e" % loss)
        lstm_param.apply_diff(lr=0.1)
        lstm_net.x_list_clear()
Ejemplo n.º 19
0
def example_0():

    # learns to repeat simple sequence from random inputs
    np.random.seed(0)

    # parameters for input data dimension and lstm cell count
    mem_cell_ct = 100
    x_dim = 50
    lstm_param = LstmParam(mem_cell_ct, x_dim)

    # print(lstm_param.wg)
    # print(lstm_param.wg[0]) # -0.1~0.1 array
    # print(len(lstm_param.wg[0])) # input 150

    lstm_net = LstmNetwork(lstm_param)
    y_list = [-0.5, 0.2, 0.1, -0.5]
    print("y_list input:", y_list)

    # input transform to vector
    input_val_arr = [np.random.random(x_dim) for _ in y_list]
    # print(lstm_param)
    # print(input_val_arr) # (4, 50) array

    # iteration 100
    for cur_iter in range(100):
        print("iter", "%2s" % str(cur_iter), end=": ")

        # next epoch input
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])

        print("y_pred = [" + ", ".join([
            "%2.5f" % lstm_net.lstm_node_list[ind].state.h[0]
            for ind in range(len(y_list))
        ]) + "]",
              end=", ")

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        print("loss:", "%.3e" % loss)

        lstm_param.apply_diff(lr=0.1)
        lstm_net.x_list_clear()
Ejemplo n.º 20
0
def bilstm_runn():
    trainX, trainY, validX, validY, testX, testY = genData()
    # learns to repeat simple sequence from random inputs
    np.random.seed(0)

    train_X = genBiData(trainX)
    train_Y = trainY
    valid_X = genBiData(validX)
    vaild_Y = validY
    test_X = genBiData(testX)
    test_Y = testY

    del trainX
    del trainY
    del testX
    del testY
    del validX
    del validY
    
    # parameters for input data dimension and lstm cell count
    mem_cell_ct = 100
    x_dim = 50
    lstm_param = LstmParam(mem_cell_ct, x_dim)
    lstm_net = LstmNetwork(lstm_param)
    y_list = [-0.5, 0.2, 0.1, -0.5]
    input_val_arr = [np.random.random(x_dim) for x in y_list]

    for cur_iter in range(100):
        print("iter", "%2s" % str(cur_iter), end=": ")
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])

        print("y_pred = [" +
              ", ".join(["% 2.5f" % lstm_net.lstm_node_list[ind].state.h[0] for ind in range(len(y_list))]) +
              "]", end=", ")

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        print("loss:", "%.3e" % loss)
        lstm_param.apply_diff(lr=0.1)
        lstm_net.x_list_clear()
Ejemplo n.º 21
0
def example_0():
    # learns to repeat simple sequence from random inputs
    np.random.seed(0)

    # parameters for input data dimension and lstm cell count
    mem_cell_ct = 100
    x_dim = 50

    y_list = [-0.8333333333, 0.33333, 0.166666667, -80.8]
    input_val_arr = [np.random.random(x_dim) for _ in y_list]

    lstm_param = LstmParam(mem_cell_ct, x_dim)
    lstm_net = LstmNetwork(lstm_param)

    lstm_param2 = LstmParam(mem_cell_ct, mem_cell_ct)
    lstm_net2 = LstmNetwork(lstm_param2)

    loss = ToyLossLayer(mem_cell_ct)

    for cur_iter in range(2000):
        # print(y_list)
        print("iter", "%2s" % str(cur_iter), end=": ")
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])
            lstm_net2.x_list_add(lstm_net.lstm_node_list[ind].state.h)

        print("y_pred = [" + ", ".join([
            "% 2.5f" % loss.value(lstm_net2.lstm_node_list[ind].state.h)
            for ind in range(len(y_list))
        ]) + "]",
              end=", ")

        lossv = lstm_net2.y_list_is(y_list, loss)
        lstm_net.y_list_is2(lstm_net2)
        print("loss:", "%.3e" % lossv)
        lstm_param2.apply_diff(lr=0.1)
        lstm_param.apply_diff(lr=0.1)
        lstm_net2.x_list_clear()
        lstm_net.x_list_clear()
Ejemplo n.º 22
0
def example_0():
    # learns to repeat simple sequence from random inputs
    np.random.seed(0)
    # 一般计算机的随机数都是伪随机数,以一个真随机数(种子)作为初始条件,然后用一定的算法不停迭代产生随机数

    # parameters for input data dimension and lstm cell count
    mem_cell_ct = 7  # hidden 输出的维度
    x_dim = 50  # 输入变量维度
    lstm_param = LstmParam(mem_cell_ct, x_dim)  # 神经网络初始化 返回初始化的net对象
    lstm_net = LstmNetwork(lstm_param)
    y_list = [0.5, 0.2, 0.1, 0.5, 0.7]
    input_val_arr = [np.random.random(x_dim) for _ in y_list]
    loss = list()
    lstm_net.net_initial(y_list)

    for cur_iter in range(400):  # 迭代次数
        print("cur iter: ", cur_iter)
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])
            print("y_pred[%d] : %f" %
                  (ind, lstm_net.lstm_node_list[ind].state.h[0]))

        loss.append(lstm_net.y_list_is(y_list, ToyLossLayer))  # 计算误差并且计算梯度
        print("loss: ", loss[cur_iter])
        lstm_param.apply_diff(lr=0.1)  # 梯度下降法 修正net
        lstm_net.x_list_clear()
    for ind in range(len(y_list)):
        print("y_pred[%d] : %f" %
              (ind, lstm_net.lstm_node_list[ind].state.h[0]))
    legend = ['loss']
    i = 0
    for y in lstm_net.y_list:
        plt.plot(y, '.')
        i += 1
        legend.append('y_' + str(i))
    plt.plot(loss)
    plt.legend(legend)
    plt.show()
Ejemplo n.º 23
0
    np.random.seed(0)
    # parameters for input data dimension and lstm cell count 
    x_dim = 50
    mem_cell_ct = 100
    lstm_param = LstmParam(mem_cell_ct, x_dim) 
    lstm_net = LstmNetwork(lstm_param)
    y_list = [-0.5,0.2,0.1,-0.5]
    input_val_arr = [np.random.random(x_dim) for _ in y_list]
    
    for cur_iter in range(100):
        print "cur iter: ", cur_iter
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])
            print "y_pred[%d] : %f" % (ind, lstm_net.lstm_node_list[ind].state.h[0])

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        print "loss: ", loss
        lstm_param.apply_diff(lr=0.1)
        lstm_net.x_list_clear()

# cur iter:  0
# y_pred[0] : 0.041349
# y_pred[1] : 0.069304
# y_pred[2] : 0.116993
# y_pred[3] : 0.165624
# loss:  0.753483886253
# ...
# cur iter:  99
# y_pred[0] : -0.500331
# y_pred[1] : 0.201063
# y_pred[2] : 0.099122
Ejemplo n.º 24
0
    def _predict(self, num_days, scr):
        # 初始化参数
        np.random.seed(0)
        mem_cell_ct = 100
        x_dim = 10
        lstm_param = LstmParam(mem_cell_ct, x_dim)
        lstm_net = LstmNetwork(lstm_param)
        days = 10
        # 需要预测的值
        y_list = self.data[days:, :]
        # 输入值
        input_val_arr = []
        for d in range(len(y_list)):
            if input_val_arr == []:
                input_val_arr = np.transpose(self.data[d:d + days, :])
            else:
                input_val_arr = np.concatenate(
                    (input_val_arr, np.transpose(self.data[d:d + days, :])), 0)

        out = ''
        # 训练1000次
        for cur_iter in range(1000):
            for ind in range(len(y_list)):
                # 训练
                lstm_net.x_list_add(input_val_arr[ind, :])

            # 计算损失
            loss = lstm_net.y_list_is(y_list, ToyLossLayer)
            # 反向误差
            lstm_param.apply_diff(lr=0.01)
            lstm_net.x_list_clear()
            if (cur_iter + 1) % 50 == 0:
                out += str(cur_iter +
                           1) + '/' + str(1000) + ' ' + str(loss) + '\n'
                if isinstance(scr, scrolledtext.ScrolledText):
                    scr.insert(
                        'end',
                        str(cur_iter + 1) + '/' + str(1000) + ' ' + str(loss) +
                        '\n')
        out += '\n'
        if isinstance(scr, scrolledtext.ScrolledText):
            scr.insert('end', '\n')

        # 查找最低的票价
        min_value = sys.maxint
        min_index = self.length
        for i in range(num_days):
            lstm_net.x_list_add(np.transpose(self.data[-days:, :])[0])
            self.data = np.append(self.data,
                                  [[lstm_net.lstm_node_list[0].state.h[0]]], 0)
            out += '预测第 ' + str(self.length + i + 1) + ' 天票价为 ' + str(
                lstm_net.lstm_node_list[0].state.h[0] * self.std +
                self.mean) + '\n'
            if lstm_net.lstm_node_list[0].state.h[0] < min_value:
                min_value = lstm_net.lstm_node_list[0].state.h[0]
                min_index = self.length + i + 1
            lstm_net.x_list_clear()
        out += '\n预测在第 ' + str(min_index) + ' 天取得最低票价 ' + str(
            min_value * self.std + self.mean) + '\n'
        if isinstance(scr, scrolledtext.ScrolledText):
            scr.insert(
                'end', '预测在第 ' + str(min_index) + ' 天取得最低票价 ' +
                str(min_value * self.std + self.mean) + '\n\n')

        return out
Ejemplo n.º 25
0
    # parameters for input data dimension and lstm cell count
    x_dim = 50
    mem_cell_ct = 100
    lstm_param = LstmParam(mem_cell_ct, x_dim)
    lstm_net = LstmNetwork(lstm_param)
    y_list = [-0.5, 0.2, 0.1, -0.5]
    input_val_arr = [np.random.random(x_dim) for _ in y_list]

    for cur_iter in range(100):
        print "cur iter: ", cur_iter
        for ind in range(len(y_list)):
            lstm_net.x_list_add(input_val_arr[ind])
            print "y_pred[%d] : %f" % (ind,
                                       lstm_net.lstm_node_list[ind].state.h[0])

        loss = lstm_net.y_list_is(y_list, ToyLossLayer)
        print "loss: ", loss
        lstm_param.apply_diff(lr=0.1)
        lstm_net.x_list_clear()

# cur iter:  0
# y_pred[0] : 0.041349
# y_pred[1] : 0.069304
# y_pred[2] : 0.116993
# y_pred[3] : 0.165624
# loss:  0.753483886253
# ...
# cur iter:  99
# y_pred[0] : -0.500331
# y_pred[1] : 0.201063
# y_pred[2] : 0.099122