[ update ]: remove asyncio features

Author: belajarqywok

training/data_processor.pyx

@@ -6,7 +6,7 @@ filterwarnings('ignore')
 
 
 """ Get Datasets """
-async def get_datasets(str datasets_path):
+def get_datasets(str datasets_path):
   cdef list items = os.listdir(datasets_path)
   cdef list csv_files = []
   cdef str item
@@ -19,7 +19,7 @@ async def get_datasets(str datasets_path):
 
 
 """ Create Sequences """
-async def create_sequences(df, int sequence_length):
+def create_sequences(df, int sequence_length):
   cdef list labels = []
   cdef list sequences = []
   cdef int i
@@ -34,7 +34,7 @@ async def create_sequences(df, int sequence_length):
 
 
 """ Pre-Process Data """
-async def preprocess_data(dataframe):
+def preprocess_data(dataframe):
   cdef str col
 
   for col in dataframe.columns:
@@ -48,7 +48,7 @@ async def preprocess_data(dataframe):
 
 
 """ Scale Data """
-async def scale_data(dataframe, scaler_cls):
+def scale_data(dataframe, scaler_cls):
   scaler = scaler_cls()
   dataframe['Close'] = scaler.fit_transform(dataframe[['Close']])
   return scaler, dataframe

training/main.pyx

@@ -24,43 +24,43 @@ from training.model_builder import (
 from warnings import filterwarnings
 filterwarnings('ignore')
 
-async def main(algorithm: str, sequence_length: int, epochs: int, batch_size: int):
+def main(algorithm: str, sequence_length: int, epochs: int, batch_size: int):
     datasets_path = './datasets'
     models_path   = './models'
     posttrained   = './posttrained'
     pickle_file   = './pickles'
 
 
-    for dataset in await get_datasets(datasets_path):
+    for dataset in get_datasets(datasets_path):
         print(f"[TRAINING] {dataset.replace('.csv', '')} ")
 
         dataframe = pd.read_csv(os.path.join(datasets_path, dataset), index_col='Date')[['Close']]
         model_file = os.path.join(models_path, f"{dataset.replace('.csv', '')}.keras")
 
         # dataframe = preprocess_data(dataframe)
         dataframe.dropna(inplace = True)
-        standard_scaler, dataframe = await scale_data(dataframe, StandardScaler)
-        minmax_scaler, dataframe = await scale_data(dataframe, MinMaxScaler)
+        standard_scaler, dataframe = scale_data(dataframe, StandardScaler)
+        minmax_scaler, dataframe = scale_data(dataframe, MinMaxScaler)
 
-        sequences, labels = await create_sequences(dataframe, sequence_length)
+        sequences, labels = create_sequences(dataframe, sequence_length)
         input_shape = (sequences.shape[1], sequences.shape[2])
 
         if algorithm == "GRU":
-            model = await gru_model(input_shape)
+            model = gru_model(input_shape)
 
         elif algorithm == "LSTM":
-            model = await lstm_model(input_shape)
+            model = lstm_model(input_shape)
 
         elif algorithm == "LSTM_GRU":
-            model = await lstm_gru_model(input_shape)
+            model = lstm_gru_model(input_shape)
 
-        else: model = await lstm_model(input_shape)
+        else: model = lstm_model(input_shape)
 
         train_size = int(len(sequences) * 0.8)
         X_train, X_test = sequences[:train_size], sequences[train_size:]
         y_train, y_test = labels[:train_size], labels[train_size:]
 
-        await train({
+        train({
 			'model': model,
 			'model_file': model_file,
 			'sequence_length': sequence_length,
@@ -70,7 +70,7 @@ async def main(algorithm: str, sequence_length: int, epochs: int, batch_size: in
 
         dataframe_json = {'Date': dataframe.index.tolist(), 'Close': dataframe['Close'].tolist()}
 
-        await save_json(
+        save_json(
           os.path.join(posttrained, f'{dataset.replace(".csv", "")}-posttrained.json'),
           dataframe_json
         )

training/model_builder.pyx

@@ -6,7 +6,7 @@ filterwarnings('ignore')
 
 
 """ GRU (Gated Recurrent Units) Model """
-async def gru_model(input_shape):
+def gru_model(input_shape):
   cdef object model = Sequential([
     GRU(50, return_sequences = True, input_shape = input_shape),
     Dropout(0.2),
@@ -28,7 +28,7 @@ async def gru_model(input_shape):
 
 
 """ LSTM (Long Short-Term Memory) Model """
-async def lstm_model(input_shape):
+def lstm_model(input_shape):
   cdef object model = Sequential([
     LSTM(50, return_sequences = True, input_shape = input_shape),
     Dropout(0.2),
@@ -53,7 +53,7 @@ async def lstm_model(input_shape):
   LSTM (Long Short-Term Memory) and
   GRU (Gated Recurrent Units) Model
 """
-async def lstm_gru_model(input_shape):
+def lstm_gru_model(input_shape):
   cdef object model = Sequential([
     LSTM(50, return_sequences = True, input_shape = input_shape),
     Dropout(0.2),

training/post_processor.pyx

@@ -6,12 +6,12 @@ filterwarnings('ignore')
 
 
 """ Inverse Transform """
-async def inverse_transform(object scaler, data):
+def inverse_transform(object scaler, data):
 	return scaler.inverse_transform(data)
 
 
 """ save json """
-async def save_json(str filename, data):
+def save_json(str filename, data):
 	with open(filename, 'w') as f:
 		json.dump(data, f)
 

training/trainer.pyx

@@ -5,7 +5,7 @@ filterwarnings('ignore')
 
 
 """ Trainer """
-async def train(dict configuration, X_train, y_train, X_test, y_test):
+def train(dict configuration, X_train, y_train, X_test, y_test):
 	cdef object early_stopping = EarlyStopping(
 		monitor = 'val_loss',
 		patience = 5,

trainingcli.py

@@ -1,4 +1,4 @@
-import asyncio
+# import asyncio
 import argparse
 from training.main import main as training
 
@@ -14,17 +14,25 @@ def main() -> None:
     parser.add_argument('-s', '--sequences', type = int, required = True, help = 'sequences length')
 
     args = parser.parse_args()
-    event_loop = asyncio.get_event_loop()
-
-    event_loop.run_until_complete(
-        training(
-            epochs     = args.epochs,
-            batch_size = args.batchs,
-            algorithm  = args.algorithm,
-            sequence_length = args.sequences
-        )
+
+    training(
+        epochs     = args.epochs,
+        batch_size = args.batchs,
+        algorithm  = args.algorithm,
+        sequence_length = args.sequences
     )
 
+    # event_loop = asyncio.get_event_loop()
+
+    # event_loop.run_until_complete(
+    #     training(
+    #         epochs     = args.epochs,
+    #         batch_size = args.batchs,
+    #         algorithm  = args.algorithm,
+    #         sequence_length = args.sequences
+    #     )
+    # )
+
 
 if __name__ == "__main__": main()