Using machine learning to predict overcooling events in datacenters
This is a kind of sequel to my post last week about using DNNs to regressively predict total datacenter energy consumption based on some features. Here I will briefly discussed a recent experiment I did to try to predict specific events before they happen. The first one is overcooling. Of course, one can easily detect overcooling by simply looking at server room temperature measurements. But by the time you discover it this way, all the unecessary energy has already been spent. The idea is to be able to predict the overcooling event before it happens, and prevent energy waste.
Hypothesis: There’s a certain time lag Δt b/n the cooling equipment kicking into gear due to environmental/control factors and the temperature actually changing in the room. Therefore, we’d like to be able to use power and outside air condition measurements taken at time t = to to predict the server room temperature at t = to + Δt.
Methods: The pre-processing and data preparation of features are as discussed in my other post. Here we will simply replace the targets in our ML model by encoded tags that represent wether an overcooling event happened or not. In order to train the model, we will first generate the target tags. We will simply take the datacenter average temperature for the same time stamps as the rest of our data (using the universal time index developed in that earlier post) and compare each value to an overcooling threshold of 75F. All time stamps that fall below this threshold are tagged 1 (i.e. there was an overcooling devent) and those that are above 75F are tagged 0 (i.e. normal operation). Now we will timeshift these encoded targets so that timestamps in the feature table will match up with target values that happen some time in the future (incremented by Δt).
As usual, the last step is to shuffle the data, use a pipeline to StandadScale all the features, and run a classifier to map the inputs to our binary targets:
shuffle_validator = cross_validation.ShuffleSplit(len(XX_sh), n_iter=5, test_size=0.2, random_state=0)
estimators = 
estimators.append((‘classifier’, clf ))
pipeline = Pipeline(estimators)
scores = cross_validation.cross_val_score(pipeline, XX_sh, YY_sh, cv=shuffle_validator)
print(“Accuracy: %0.2f “ % (scores.mean()*100))
I ran a Random Forest classifier (N = 20) with Δt = 5 x 5 min = 25 min:
This basically means that its possible to predict an overcooling event 25 mins before it happens with an accuracy of 92.63%.
C’est pas mal ca :-)