This post picks up from the last post where we ended up simulating the rate of change of a parameter using parallel computing. The current post focuses on the last step of this series – generating real-world data using the simulated rates via parallel computing.

Simulating Conditions

Before you start the actual simulation, you need to ask yourself –

• How much data (number of observations) do you need to simulate?
• If it is a batch process that generates real world data (for example, a manufacturing pipeline), how long does each batch lasts for?
• As this would be a time-dependent data, what is the required frequency that mimics the real world data?

For example, a company has been manufacturing a chemical compound for 2 years using multiple batches. Each batch runs for 14 days, and data is collected for several key performance indicators (KPIs) at a frequency of 1 min. In this case, a batch will contain 14,400 observations (10 days x 24 hours x 60 minutes x 1). In our example, we will simulate a batch run of 14 days with the frequency of data collection set at 30 seconds. To solve this problem, we will use parallel computing in Python and our custom-made simulating function.

Parallel Computing in Python – Pool Process

To carry out the simulation on a powerful server, we can utilise Python’s parallel computing function called pool. We can launch several pool workers (processes) simulatneously, each simulating a batch for 2 weeks at a frequency of 30 seconds. For our purpose, we will launch 75 workers, each running 15 batches, one at a time. The following code explains it well –

sim_df = pool.map(simulate_corr, runs, chunksize=15)

Here, pool size is 75, chunksize is 15, runs is a list of 1125 (it tells to run each pool worker 15 times), and simulate_df is the function which is passed to each pool worker. Global variables samples and freq have been initialised with 40320 (14 days x 24 hours x 60 min x 2 for a frequency of 30 seconds) and 30 respectively. Once all pool workers have finished their assigned tasks, the output is consolidated into a single df called sim_df. As each worker is executed independently, there is no dependency between any workers, and this simulates a ‘batch’ production environment (i.e. each batch is run independently of each other).

Simulating Function

As we want to simulate observations which are comparable to the original dataset, one of the key parameters to keep in check is correlation. In a manufacturing environment, several KPIs would be dependent on each other, thereby having a correlation among them. For example, an increase in oxygen levels is correlated with a decrease in nitogen levels in a bioreactor. To simulate real world data, we must try to keep the correlation as close as possible to the correlation in the original dataset.

To add randomness in how we pick a column to simulate against, we follow the algorithm as described – to simulate a row of observation, pick a random column, and simulate other columns with respect to the random column, keeping the correlation the same as in the original dataset. This is done by the line below –

nextValue = start + (sdev[col]/sdev[randomCol])*corr*delta*freq

Here, start is the starting value (mean) or the last value simulated, randomCol is a random column, col is one of the other columns, corr is the correlation between randomCol and col in the original dataset, delta is a random simulated rate value of col (we simulated this in Part II), and freq is in seconds. sdev is the standard deviation of columns calculated from the original dataset. This formula gives the next simulated value (nextValue) for col and further checks are done to ensure this value remains within the upper and lower bounds. The above process is repeated until all columns have been simulated with respect to randomCol. The new row is appended to a data.frame and the loop continues until the Pool process reaches the maximum number of iterations.

Conclusion

In this example, the simulations ran for ~40 days on a 80 core server, each core with 4GB RAM. The resulting dataset contained ~44 million time series simulated observations, all created from scratch and using the original small dataset. The complete code and detailed explanation is available on my Github here.

Thank you for reading. I will be starting a new series on how to analyse big data and build machine learning models using Spark, and we will be using part of this dataset for the analyses.