should model.compile() be run prior to using model.load_weights(), if model has been only slightly changed say dropout?
The model.compile() method does not touch the weights in any way. 
Its purpose is to create a symbolic function adding the loss and the optimizer to the model's existing function. 
You can compile the model as many times as you want, whenever you want, and your weights will be kept intact. 
Possible consequences of compile
If you got a model, well trained for some epochs, it's optimizer (depending on what type and parameters you chose for it) will also be trained for that specific epochs. 
Compiling will make you lose the trained optimizer, and your first training batches might experience some bad results due to learning rates not suited to the current state of the model. 
Other than that, compiling doesn't cause any harm.
With training & validation through a dataset for nearly 24 epochs, intermittently 8 epochs at once and saving weights cumulatively after each interval. 
I observed a constant declining train & test-loss for first 16 epochs, post which the training loss continues to fall whereas test loss rises so i think it's the case of Overfitting.
For which i tried to resume training with weights saved after 16 epochs with change in hyperparameters say increasing dropout_rate a little.
Therefore i reran the dense & transition blocks with new dropout to get identical architecture with same sequence & learnable parameters count.
Now when i'm assigning previous weights to my new model(with new dropout) with model.load_weights() and compiling thereafter.
i see the training loss is even higher, that should be initially (blatantly with increased inactivity of random nodes during training) but later also it's performing quite unsatisfactory,
so i'm suspecting maybe compiling after loading pretrained weights might have ruined the performance? 
what's reasoning & recommended sequence of model.load_weights() & model.compile()? i'd really appreciate any insights on above case.