Saya baru mengenal ML dan TensorFlow (saya mulai sekitar beberapa jam yang lalu), dan saya mencoba menggunakannya untuk memprediksi beberapa titik data berikutnya dalam rangkaian waktu. Saya menerima masukan saya dan melakukan ini dengannya:

/----------- x ------------\
.-------------------------------.
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
'-------------------------------'
     \----------- y ------------/

Apa yang saya pikir saya lakukan adalah menggunakan x sebagai input data dan y sebagai output yang diinginkan untuk input itu, sehingga diberikan 0-6 saya bisa mendapatkan 1-7 (7 khususnya). Namun, ketika saya menjalankan grafik dengan x sebagai input, yang saya dapatkan adalah prediksi yang lebih mirip x daripada y .

Berikut kodenya (berdasarkan posting ini dan posting ini ):

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plot
import pandas as pd
import csv

def load_data_points(filename):
    print("Opening CSV file")
    with open(filename) as csvfile:
        print("Creating CSV reader")
        reader = csv.reader(csvfile)
        print("Reading CSV")
        return [[[float(p)] for p in row] for row in reader]

flatten = lambda l: [item for sublist in l for item in sublist]

data_points = load_data_points('dataset.csv')

print("Loaded")

prediction_size = 10
num_test_rows = 1
num_data_rows = len(data_points) - num_test_rows
row_size = len(data_points[0]) - prediction_size

# Training data
data_rows = data_points[:-num_test_rows]
x_data_points = np.array([row[:-prediction_size] for row in data_rows]).reshape([-1, row_size, 1])
y_data_points = np.array([row[prediction_size:] for row in data_rows]).reshape([-1, row_size, 1])

# Test data
test_rows = data_points[-num_test_rows:]
x_test_points = np.array([[data_points[0][:-prediction_size]]]).reshape([-1, row_size, 1])
y_test_points = np.array([[data_points[0][prediction_size:]]]).reshape([-1, row_size, 1])

tf.reset_default_graph()

num_hidden = 100

x = tf.placeholder(tf.float32, [None, row_size, 1])
y = tf.placeholder(tf.float32, [None, row_size, 1])

basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=num_hidden, activation=tf.nn.relu)
rnn_outputs, _ = tf.nn.dynamic_rnn(basic_cell, x, dtype=tf.float32)

learning_rate = 0.001

stacked_rnn_outputs = tf.reshape(rnn_outputs, [-1, num_hidden])
stacked_outputs = tf.layers.dense(stacked_rnn_outputs, 1)
outputs = tf.reshape(stacked_outputs, [-1, row_size, 1])

loss = tf.reduce_sum(tf.square(outputs - y))
optimizer = tf.train.AdamOptimizer(learning_rate)
training_op = optimizer.minimize(loss)

init = tf.global_variables_initializer()

iterations = 1000

with tf.Session() as sess:
    init.run()
    for ep in range(iterations):
        sess.run(training_op, feed_dict={x: x_data_points, y: y_data_points})
        if ep % 100 == 0:
            mse = loss.eval(feed_dict={x: x_data_points, y: y_data_points})
            print(ep, "\tMSE:", mse)

    y_pred = sess.run(stacked_outputs, feed_dict={x: x_test_points})

    plot.rcParams["figure.figsize"] = (20, 10)

    plot.title("Actual vs Predicted")
    plot.plot(pd.Series(np.ravel(x_test_points)), 'g:', markersize=2, label="X")
    plot.plot(pd.Series(np.ravel(y_test_points)), 'b--', markersize=2, label="Y")
    plot.plot(pd.Series(np.ravel(y_pred)), 'r-', markersize=2, label="Predicted")
    plot.legend(loc='upper left')
    plot.xlabel("Time periods")
    plot.tick_params(
        axis='y',
        which='both',
        left='off',
        right='off',
        labelleft='off')
    plot.show()

Hasil yang ditunjukkan pada grafik di bawah ini adalah prediksi yang mengikuti x , alih-alih bergeser ke kiri (dan termasuk titik prediksi di sebelah kanan) karena harus menyerupai y . Jelas keinginannya adalah agar garis merah sedekat mungkin dengan garis biru.

Saya tidak tahu apa yang saya lakukan dengan semua ini, jadi tolong ELI5.

Oh, juga, poin data saya adalah angka yang cukup kecil (urutan 0,0001). Jika saya tidak mengalikannya dengan, katakanlah, 1000000, hasilnya sangat kecil sehingga garis merah hampir rata di bagian bawah grafik. Mengapa? Saya menduga itu karena kuadrat dalam fungsi kebugaran. Haruskah data dinormalisasi sebelum digunakan, dan jika demikian, untuk apa? 0-1? Jika saya menggunakan:

normalized_points = [(p - min_point) / (max_point - min_point) for p in data_points]

prediksi saya berfluktuasi lebih liar saat berlangsung:

Sunting: Saya bodoh dan hanya memberikan satu contoh untuk belajar, bukan 500, bukan? Jadi saya harus memberikan beberapa sampel 500 poin, kan?

Oke, mari kita mulai bagian demi bagian. Ada beberapa bagian di sini di mana Anda tidak mempertimbangkan bias di jaringan Anda.

Memilih input dan output Anda

Jika vektor 0-6 ditentukan benar-benar tidak perlu untuk output 1-7. 1-6 sudah dikenal dan menambahkan output tambahan hanya akan menambah kompleksitas pada model Anda. Kecuali jika Anda memiliki sejumlah besar data, Anda ingin menjaga model Anda sesederhana mungkin untuk mendapatkan kinerja yang baik. Jadi, saya akan menghasilkan neuron sederhana dengan nilai kontinu. Anda dapat menggunakan RMSE sebagai fungsi kerugian Anda dengan output regresi dari jaringan saraf Anda.

Selain itu, Anda harus melengkapi sampel yang Anda masukkan ke dalam ruang input Anda dengan beberapa informasi tambahan yang Anda pikir akan berisi informasi tentang garis tren. Misalnya, jika saya memiliki 2 produk berbeda, bitcoin dan emas, dan vektor inputnya sama, saya mungkin berharap emas memiliki fluktuasi yang sangat sedikit tetapi bitcoin memiliki fluktuasi yang sangat tinggi.

Fitur input Anda ke jaringan Anda berisi semua informasi yang akan dipelajari jaringan Anda. Dengan demikian, Anda ingin memastikan bahwa Anda memberikan informasi yang cukup untuk memiliki prediksi yang berarti.

Pembelajaran mendalam adalah lapar data

Anda membutuhkan sekitar 100.000+ contoh. Setiap instance adalah serangkaian fitur. Ini harus ditarik secara independen dan sedemikian rupa sehingga didistribusikan secara identik. Dengan kata lain, Anda ingin mendapatkan beberapa trendline dari sumber data yang bervariasi yang ingin Anda gunakan dengan jaringan Anda dan kemudian Anda akan secara acak menggambar 0-6 poin, itu fitur Anda, dan 7 yang akan menjadi label Anda.

Pertimbangkan distribusi data yang Anda coba pelajari. Jika Anda ingin jaringan Anda mengklasifikasikan kucing / anjing, Anda perlu memberikan berbagai macam kucing dan anjing yang tampak berbeda sehingga jaringan dapat mengidentifikasi varian yang ada di kedua kelas ini. Jika Anda membatasi sumber data terlalu banyak maka akan memiliki bias tinggi dan tidak akan menggeneralisasi ke data baru yang nantinya akan Anda masukkan ke dalamnya.

Cobalah hal-hal ini dan beri tahu kami apa yang terjadi.

Mungkin prediksi yang sama dengan input mencerminkan bahwa jaringan Anda kurang terlatih. Apa yang disebut model persistensi untuk prediksi deret waktu, sering digunakan sebagai dasar untuk model lain. Model ketekunan menggunakan observasi terakhir sebagai prediksi. Ini sederhana dan seringkali menghasilkan akurasi yang masuk akal. Dugaan saya adalah bahwa jaringan Anda mulai dengan mempelajari model ketekunan, dan hanya jika Anda melatihnya lebih banyak dan dimungkinkan untuk membuat model yang lebih baik, ia akan mempelajarinya - tetapi ini membutuhkan banyak pelatihan.