【GitHub】tensorflow-lstm-regression

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

tensorflow-lstm-regression

This is an example of a regressor based on recurrent networks:

The objective is to predict continuous values, sin and cos functions in this example, based on previous observations using the LSTM architecture.

Install and RunCreate a Virtual Environment

It is reccomended that you create a virtualenv for the setup since this example is highly dependant on the versions set in the requirements file.

$ virtualenv ~/python/ltsm$ source ~/python/ltsm/bin/activate(ltsm) $Install Requirements

This example depends on tensorflow-0.11.0 to work. You will first need to install the requirements. You will need the appropriate version of tensorflow for your platform, this example is for mac. For more details goto TAG tensorflow-0.11.0 Setup

(ltsm) $ pip install -U https://storage.googleapis.com/t ... .0-py3-none-any.whl(ltsm) $ pip install -r ./requirements.txtRunning on Jupyter

Three Jupyter notebooks are provided as examples on how to use lstm for predicting shapes. They will be available when you start up Jupyter in the project dir.

(ltsm) $ jupyter notebook

本帖隐藏的内容

tensorflow-lstm-regression-master.zip (257.06 KB)

2017-4-26 10:23:31 上传

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏3 回帖

关键词：regression regressio regress Tensor GitHub continuous objective activate previous example

1. import numpy as np
   
2. import pandas as pd
   
3. import tensorflow as tf
   
4. from tensorflow.python.framework import dtypes
   
5. from tensorflow.contrib import learn as tflearn
   
6. from tensorflow.contrib import layers as tflayers
   
7. 
   
8. 
   
9. def x_sin(x):
   
10.     return x * np.sin(x)
    
11. 
    
12. 
    
13. def sin_cos(x):
    
14.     return pd.DataFrame(dict(a=np.sin(x), b=np.cos(x)), index=x)
    
15. 
    
16. 
    
17. def rnn_data(data, time_steps, labels=False):
    
18.     """
    
19.     creates new data frame based on previous observation
    
20.       * example:
    
21.         l = [1, 2, 3, 4, 5]
    
22.         time_steps = 2
    
23.         -> labels == False [[1, 2], [2, 3], [3, 4]]
    
24.         -> labels == True [3, 4, 5]
    
25.     """
    
26.     rnn_df = []
    
27.     for i in range(len(data) - time_steps):
    
28.         if labels:
    
29.             try:
    
30.                 rnn_df.append(data.iloc[i + time_steps].as_matrix())
    
31.             except AttributeError:
    
32.                 rnn_df.append(data.iloc[i + time_steps])
    
33.         else:
    
34.             data_ = data.iloc[i: i + time_steps].as_matrix()
    
35.             rnn_df.append(data_ if len(data_.shape) > 1 else [[i] for i in data_])
    
36. 
    
37.     return np.array(rnn_df, dtype=np.float32)
    
38. 
    
39. 
    
40. def split_data(data, val_size=0.1, test_size=0.1):
    
41.     """
    
42.     splits data to training, validation and testing parts
    
43.     """
    
44.     ntest = int(round(len(data) * (1 - test_size)))
    
45.     nval = int(round(len(data.iloc[:ntest]) * (1 - val_size)))
    
46. 
    
47.     df_train, df_val, df_test = data.iloc[:nval], data.iloc[nval:ntest], data.iloc[ntest:]
    
48. 
    
49.     return df_train, df_val, df_test
    
50. 
    
51. 
    
52. def prepare_data(data, time_steps, labels=False, val_size=0.1, test_size=0.1):
    
53.     """
    
54.     Given the number of `time_steps` and some data,
    
55.     prepares training, validation and test data for an lstm cell.
    
56.     """
    
57.     df_train, df_val, df_test = split_data(data, val_size, test_size)
    
58.     return (rnn_data(df_train, time_steps, labels=labels),
    
59.             rnn_data(df_val, time_steps, labels=labels),
    
60.             rnn_data(df_test, time_steps, labels=labels))
    
61. 
    
62. 
    
63. def load_csvdata(rawdata, time_steps, seperate=False):
    
64.     data = rawdata
    
65.     if not isinstance(data, pd.DataFrame):
    
66.         data = pd.DataFrame(data)
    
67. 
    
68.     train_x, val_x, test_x = prepare_data(data['a'] if seperate else data, time_steps)
    
69.     train_y, val_y, test_y = prepare_data(data['b'] if seperate else data, time_steps, labels=True)
    
70.     return dict(train=train_x, val=val_x, test=test_x), dict(train=train_y, val=val_y, test=test_y)
    
71. 
    
72. 
    
73. def generate_data(fct, x, time_steps, seperate=False):
    
74.     """generates data with based on a function fct"""
    
75.     data = fct(x)
    
76.     if not isinstance(data, pd.DataFrame):
    
77.         data = pd.DataFrame(data)
    
78.     train_x, val_x, test_x = prepare_data(data['a'] if seperate else data, time_steps)
    
79.     train_y, val_y, test_y = prepare_data(data['b'] if seperate else data, time_steps, labels=True)
    
80.     return dict(train=train_x, val=val_x, test=test_x), dict(train=train_y, val=val_y, test=test_y)
    
81. 
    
82. 
    
83. def lstm_model(num_units, rnn_layers, dense_layers=None, learning_rate=0.1, optimizer='Adagrad'):
    
84.     """
    
85.     Creates a deep model based on:
    
86.         * stacked lstm cells
    
87.         * an optional dense layers
    
88.     :param num_units: the size of the cells.
    
89.     :param rnn_layers: list of int or dict
    
90.                          * list of int: the steps used to instantiate the `BasicLSTMCell` cell
    
91.                          * list of dict: [{steps: int, keep_prob: int}, ...]
    
92.     :param dense_layers: list of nodes for each layer
    
93.     :return: the model definition
    
94.     """
    
95. 
    
96.     def lstm_cells(layers):
    
97.         if isinstance(layers[0], dict):
    
98.             return [tf.nn.rnn_cell.DropoutWrapper(tf.nn.rnn_cell.BasicLSTMCell(layer['num_units'],
    
99.                                                                                state_is_tuple=True),
    
100.                                                   layer['keep_prob'])
     
101.                     if layer.get('keep_prob') else tf.nn.rnn_cell.BasicLSTMCell(layer['num_units'],
     
102.                                                                                 state_is_tuple=True)
     
103.                     for layer in layers]
     
104.         return [tf.nn.rnn_cell.BasicLSTMCell(steps, state_is_tuple=True) for steps in layers]
     
105. 
     
106.     def dnn_layers(input_layers, layers):
     
107.         if layers and isinstance(layers, dict):
     
108.             return tflayers.stack(input_layers, tflayers.fully_connected,
     
109.                                   layers['layers'],
     
110.                                   activation=layers.get('activation'),
     
111.                                   dropout=layers.get('dropout'))
     
112.         elif layers:
     
113.             return tflayers.stack(input_layers, tflayers.fully_connected, layers)
     
114.         else:
     
115.             return input_layers
     
116. 
     
117.     def _lstm_model(X, y):
     
118.         stacked_lstm = tf.nn.rnn_cell.MultiRNNCell(lstm_cells(rnn_layers), state_is_tuple=True)
     
119.         x_ = tf.unpack(X, axis=1, num=num_units)
     
120.         output, layers = tf.nn.rnn(stacked_lstm, x_, dtype=dtypes.float32)
     
121.         output = dnn_layers(output[-1], dense_layers)
     
122.         prediction, loss = tflearn.models.linear_regression(output, y)
     
123.         train_op = tf.contrib.layers.optimize_loss(
     
124.             loss, tf.contrib.framework.get_global_step(), optimizer=optimizer,
     
125.             learning_rate=learning_rate)
     
126.         return prediction, loss, train_op
     
127. 
     
128.     return _lstm_model

复制代码

谢谢楼主分享！

多谢楼主。。。