## 3 Results  
Each model was structured with a similar kind of architecture, as each model has: an input layer, a 1-layer RNN type of cell (LSTM, GRU, Simple), and a dense layer for one-dimensional outputs. Each RNN model has a specific type of layer on the second layer; the loss function does not change the architecture but how weights are updated. Table 2 represents the architectures of these models, where the output shape for the first layer (input) defines the form of input data: \(n_{seq}\) represents the sequence size (5), and thus the set of samples used; \(n_{feat}\) means the number of source features used (87). While the dataset was composed of 96 features (32 data-available markers and 3 dimensions, \(32\times 3=96\)), missing values were present in 9 features (LMT1X, LMT1Y, LMT1Z, L.ASISX, L.ASISY, L.ASISZ, R.MT1X, R.MT1Y, R.MT1Z); hence, these features were dropped, and thus the number of features used was 87 (\(96-9=87\)). The output shapes for the second and third layers were their numbers of neurons; the only modifiable parameter was the number of neurons in the second layer, as the number of neurons in the third layer had to be three due to the three force dimensions that were being predicted (\(F_{x}\), \(F_{y}\), \(F_{z}\)). Even though each model employs the same architecture, each type of layer has a different number of trainable parameters; thus, the number of trainable parameters varies depending on the model's architecture. With LSTM having the highest number of \(n_{param}\) (3072) and Simple having the lowest (768), the difference comes down to the cell's architecture. As the cell's complexity increases, the number of parameters also increases. However, this does not necessarily mean that the model would take more time to train as the number of parameters increases, as the number of parameters only has to do with the modification of the cell depending on the weights; thus, it mainly represents its flexibility. \begin{table}
\begin{tabular}{c c c c c c} \hline \hline
**Type of** & \(n_{layer}\) & **Layer** &
\begin{tabular}{c} **Output** \\ **Shape** \\ \end{tabular} & \(n_{param}\) & **Total**\(n_{param}\) \\ \hline \multirow{3}{*}{LSTM} & 1 & Input & (\(n_{seq}\), \(n_{feat}\)) & 0 & \\  & 2 & LSTM & (8) & 3072 & 3099 \\  & 3 & Dense & (3) & 27 & \\ \hline \multirow{3}{*}{GRU} & 1 & Input & (\(n_{seq}\), \(n_{feat}\)) & 0 & \\  & 2 & GRU & (8) & 2328 & 2355 \\  & 3 & Dense & (3) & 27 & \\ \hline \multirow{3}{*}{Simple} & 1 & Input & (\(n_{seq}\), \(n_{feat}\)) & 0 & \\  & 2 & Simple & (8) & 768 & 795 \\ \cline{1-1}  & 3 & Dense & (3) & 27 & \\ \hline \hline \end{tabular}
\end{table} 
Table 2: In each RNN architecture, for each model that has a specific type of layer, the output shape is used for each force prediction on a given dataset, where \(n_{seq}=5\) and \(n_{feat}=87\). RNN training time uses epochs. A GeForce GTX 1060 6 GB was used to train each DL model, although, depending on the layer type, sampling technique, and loss function selected, training time per epoch (\(t_{epoch}\)) and total elapsed training time (\(t_{dapsed}\)) changed. An epoch is one forward and backward propagation for the DL model; hence, numerous epochs train the DL model to understand the training data better, thereby generalizing it better for the validation and testing datasets. \(t_{epoch}\) for each model trained corresponds to the average time per epoch and determines the model that is less computationally expensive, and thus more efficient. Mean training time per epoch, shown in Equation (14), is used to calculate \(t_{elapsed}\) until results, depending on the combinations of layer type, sampling method, and loss function in Table 3.  
\[t_{elapsed}=t_{epoch}\cdot n_{epochs} \tag{14}\]  
It is essential to see which combination has the fewest \(t_{elapsed}\), as DL models could take a considerable amount of time to train. The only things that changed were the layer type, sampling method, and loss function, as other parameters and data remained constant.