Callback function in VQE do not return the intermediate values of the parameters

In case someone sees this, and would like to have a workaround, the following code is inspired by the answer due to @KAJ226. Essentially, instead of saving the parameters into a list, we print them into a file so that we can extract them if needed. I compare the following three energies, the values saved by the call-back, the values recalculated with the parameters printed out to the file, and the values recalculated with the parameters saved by the call-back. It is shown that the first and the second values agree with each other. I attached the figure below.

import numpy as np
import pylab

from qiskit import BasicAer
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.aqua import QuantumInstance, aqua_globals
from qiskit.aqua.algorithms import VQE, NumPyMinimumEigensolver
from qiskit.aqua.components.initial_states import Zero
from qiskit.aqua.components.optimizers import COBYLA, L_BFGS_B, SLSQP
from qiskit.circuit.library import TwoLocal

pauli_dict = {
    'paulis': [{"coeff": {"imag": 0.0, "real": -1.052373245772859}, "label": "II"},
              {"coeff": {"imag": 0.0, "real": 0.39793742484318045}, "label": "ZI"},
              {"coeff": {"imag": 0.0, "real": -0.39793742484318045}, "label": "IZ"},
              {"coeff": {"imag": 0.0, "real": -0.01128010425623538}, "label": "ZZ"},
              {"coeff": {"imag": 0.0, "real": 0.18093119978423156}, "label": "XX"}
              ]
}

qubit_op = WeightedPauliOperator.from_dict(pauli_dict)


num_qubits = qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = TwoLocal(num_qubits, 'ry', 'cz', initial_state=init_state)

counts = []
values = []
para3 = []
with open('out.txt', 'w') as f: 
    pass
def store_intermediate_result(eval_count, parameters, mean, std):
    counts.append(eval_count)
    values.append(mean)
    para3.append( parameters ) 
#     print( parameters )
    with open('out.txt', 'a') as f:
        for item in parameters:
            f.write( "%f " % item )
        f.write( "n" )
    

algo = VQE(qubit_op, var_form, COBYLA(), include_custom=True , callback=store_intermediate_result)
backend = Aer.get_backend('qasm_simulator')
algo_result = algo.run(backend)

with open('out.txt' ) as f:
    para2 = [line.split() for line in f]        

para = []
for x in para2:
    para.append( [float(y) for y in x ] )


counts = np.asarray(counts)
values = np.asarray(values)

values2 = []
for x in counts:
    algo = VQE(qubit_op, var_form, COBYLA(maxiter= 0), include_custom=True , initial_point = para[x-1])
    backend = Aer.get_backend('qasm_simulator')
    algo_result = algo.run(backend)

    values2.append( algo_result['eigenvalue'] )

values3 = []    
for x in para3:
    algo = VQE(qubit_op, var_form, COBYLA(maxiter= 0), include_custom=True , initial_point = x )
    backend = Aer.get_backend('qasm_simulator')
    algo_result = algo.run(backend)

    values3.append( algo_result['eigenvalue'] )
    
fig,ax = pylab.subplots()
Numval = 60
ax.plot( counts[:Numval]  , values[:Numval] , 'ro' , label ='energy output by call-back')
ax.plot( counts[:Numval]  , values2[:Numval] , 'bx' , label = 'energy recalculated with para print-out (correct)')
ax.plot( counts[:Numval]  , values3[:Numval] , 'k*' , label = 'energy recalculated with para by the calle-back (wrong)')
pylab.legend(loc='upper right')