Az egyik kedvenc dolgom a Machine Learninggel az előrejelzés, ez nagyjából azt jelenti, hogy a múlt adatai alapján megjósolom a jövőt, és mi is lehetne jobb projektben, mint a tőzsde előrejelzése! Először is a Google Colabot fogjuk használni ennek a kódnak a futtatásához, szerencsére számunkra ez a kód nagyjából már kidolgozott volt, kérjük, adjon minden elismerést ennek a webhelynek a kódért, különben kezdjük! "Itt a link a Google Colab projekt eléréséhez", és ha úgy tetszik, átmásolhatja a kódot a Python IDE-be.
Gyors megjegyzés:Ez egy kissé fejlettebb oktatóanyag, feltételezem, hogy tudja, hogy a Python/objektum orientált programozás, egy kis gépi tanulás és a Pandas / Numpy területén jártas. Vannak olyan oktatóprogramjaim, amelyek felgyorsítják a felgyorsítást, de itt van egy „Alapvető bevezetés a gépi tanuláshoz”, amit leírtam. Oké, kezdjük!
A csomagok importálása
Mint mindig, ezeket a csomagokat importálnunk kell, a numpy, pandas, matplotlib és SciKit-Learn alkalmazásokat használjuk, ezeket pip telepítheti, de mivel a Google Colab-ot használjuk, ezek már be vannak építve. Ezeket a csomagokat importáljuk. ezzel:
import numpy as np import pandas as pd import matplotlib.pyplot as plt from sklearn.metrics import mean_absolute_error as mae from sklearn.preprocessing import StandardScaler
Fantasztikus! Ezután az adatkészletet kell importálnunk, szerencsére a LazyProgrammernek már van egy adatkészlete, amelyet előre tudunk importálni, így menjünk tovább és használjuk a következő parancsot:
df = pd.read_csv(‘https://raw.githubusercontent.com/lazyprogrammer/machine_learning_examples/master/tf2.0/sbux.csv')
Félelmetes, ha már van egy másik adatkészlete, amelyet szeretne választani, akkor helyettesítse azt a csv-t a másik adatkerettel. Ezután szeretnénk megszerezni a részvényeink záró árfolyamát, és azt egy másik változóban tárolni, valamint át akarjuk alakítani ezt az adatkeretet, ezt a következő sor segítségével tesszük:
series = df[‘close’].values.reshape(-1, 1)
Nagy! Azért tároljuk ezt egy másik változóban, mert a gépi tanulási modellünket az adott értékhez fogjuk illeszteni. Ezután normalizálnunk kell az adatokat, először a skálázó deklarálásával kezdjük, ez lehetővé teszi, hogy az átlagérték 0 legyen, miközben a szórása 1, majd a fenti kódba illesztjük a közeli adatainkat. az imént létrehozott skálázóhoz, majd a „sorozat” változót visszaadjuk a transzformált skálázónak, amelyet a Numpy „.flatten” parancsával 1D tömbbé alakítunk. Soknak tűnik (és az is), de itt van a kód ehhez:
scaler = StandardScaler() scaler.fit(series[:len(series) // 2]) series = scaler.transform(series).flatten()
Fantasztikus! Most létre kell hoznunk egy új adatkeretet, amely segít nekünk tárolni az adatokat, haladjunk soronként (majdnem), menjünk tovább, és kezdjük a következő változók / üres adatkeretek létrehozásával:
T = 10 D = 1 X = [] Y = []
Félelmetes, most a „T”-t fogjuk használni múltbeli változónkként, azaz hány napot fogunk visszamenni, hogy megjósoljuk a jövőt. Ezután egy for ciklust fogunk használni, hogy végigmenjünk a sorozat adatainkon, tehát kezdjük a for ciklus deklarálásával, a következő sort fogjuk használni:
for t in range(len(series) — T):
Figyeljük meg, hogy kis „t” betűt használunk, ami ebben a konkrét példában a számlálónk, a következő lépésben töltsük ki a for ciklust, így most a sorozat adatait a számlálónkkal egy másik változóba (ebben a példában x) szeretnénk tárolni. az adatkészlet feldarabolása, majd az adatok hozzáfűzése a fent deklarált nagybetűs X adatkeretünkhöz, itt vannak a for ciklusunk sorai:
x = series[t:t+T] X.append(x)
Most ugyanezt tesszük, de ahelyett, hogy felvágnánk az adatkészletet, csak számlálóként használnánk a sorozatadatkészleten belül, majd ugyanezeket az adatokat hozzáfűzzük a korábban létrehozott Y adatkerethez.
y = series[t+T] Y.append(y)
Végül át akarjuk alakítani az adatkeretünket, ezzel alapvetően új formát adunk az adatkeretünknek anélkül, hogy az adatkeretben lévő adatokat megváltoztatnánk, majd létrehozunk egy tömböt az „Y” adatkerethez is, végül megkapja az „X” tömb hosszát, és egy új „N” nevű változóban tárolja.
X = np.array(X).reshape(-1, T) Y = np.array(Y) N = len(X) print(“X.shape”, X.shape, “Y.shape”, Y.shape)
Fantasztikus! Most egy osztályt kell létrehoznunk a gépi tanulási modellünkhöz, ez a móka! Kezdjük azzal, hogy létrehozunk egy BaselineModel nevű osztályt, majd adjunk meg egy függvényt a következő kóddal:
class BaselineModel:
def predict(self, X):
return X[:,-1] # return the last value for each input sequence
Ezután fel kell osztanunk adatainkat egy vonat- és tesztkészletre. Ezt úgy tesszük, hogy létrehozzuk az Xtrain & Train változókat, majd a korábban használt „X” és „N” változókat használjuk a változók kitöltéséhez adatokkal, lényegében ugyanezt tesszük az „Xtest” és „Ytest” változóinkkal. tesztkészletünk adatainak másik fele:
Xtrain, Ytrain = X[:-N//2], Y[:-N//2] Xtest, Ytest = X[-N//2:], Y[-N//2:]
Fantasztikus! Következő lépésként menjünk előre és állítsuk be a modellünket, létrehozunk egy „modell” változót, amely tartalmazza a „BaselineModel” osztályunkat, majd létrehozunk néhány új változót a képzési és tesztelési adatkereteink átadásához. a következő kód használatával:
model = BaselineModel() Ptrain = model.predict(Xtrain) Ptest = model.predict(Xtest)
Nagy! Most folytatjuk a tömbök újraformázását és egy másik változóba való tárolását, valamint létrehozzuk az 1D tömböt a Numpy segítségével:
Ytrain2 = scaler.inverse_transform(Ytrain.reshape(-1, 1)).flatten() Ytest2 = scaler.inverse_transform(Ytest.reshape(-1, 1)).flatten() Ptrain2 = scaler.inverse_transform(Ptrain.reshape(-1, 1)).flatten() Ptest2 = scaler.inverse_transform(Ptest.reshape(-1, 1)).flatten()
Majdnem kész! Most megyünk tovább, és elküldjük adatainkat nagyjából előrejelzésre, a jövőbeli adatok bekerülnek az "előrejelzés" változónkba, majd az adatainkat a matplotlib csomag segítségével ábrázoljuk! Ez a kód ehhez:
# right forecast forecast = [] input_ = Xtest[0] while len(forecast) < len(Ytest): f = model.predict(input_.reshape(1, T))[0] forecast.append(f) # make a new input with the latest forecast input_ = np.roll(input_, -1) input_[-1] = f plt.plot(Ytest, label=’target’) plt.plot(forecast, label=’prediction’) plt.legend() plt.title(“Right forecast”) plt.show()
És ez a mi kimenetünk!
Gratula! Éppen most jósolta meg a jövőt a Machine Learning segítségével! Ez egy elég tisztességes projekt befejezése, sok alapismerettel foglalkoztunk, valamint néhány nagyon fejlett technikát is, büszkének kell lenni, hogy eljutott idáig! Azt is tanácsolom, hogy kutasson tovább ebben a projektben, mit tud módosítani? Van valami fejlesztés a modellen? Próbáljon meg különböző adatkészleteket használni, és módosítsa a paramétereket, hogy lássa, mennyire pontos a modell.
