How does a trained SVR model predict values?

I've been trying to understand how does a model trained with support vector machines for regression predict values. I have trained a model with the sklearn.svm.SVR, and now I'm wondering how to "manually" predict the outcome of an input.
Some background - the model is trained with kernel SVR, with RBF function and uses the dual formulation. So now I have arrays of the dual coefficients, the indexes of the support vectors, and the support vectors themselves.
I found the function which is used to fit the hyperplane but I've been unsuccessful in applying that to "manually" predict outcomes without the function .predict.
The few things I tried all include the dot products of the input (features) array, and all the support vectors.

If anyone ever needs this, I've managed to understand the equation and code it in python.
The following is the used equation for the dual formulation:

where N is the number of observations, and α_i multiplied by y_i are the dual coefficients found from the model's attributed model.dual_coef_. The x_i^T are some of the observations used for training (support vectors) accessed by the attribute model.support_vectors_ (transposed to allow multiplication of the two matrices), x is the input vector containing a value for each feature (its the one observation for which we want to get prediction), and b is the intercept accessed by model.intercept_.
The x_i^T and x, however, are the observations transformed in a higher-dimensional space, as explained by mery in this post.
The calculation of the transformation by RBF can be either applied manually step by stem or by using the sklearn.metrics.pairwise.rbf_kernel.
With the latter, the code would look like this (my case shows I have 589 support vectors, and 40 features).
First we access the coefficients and vectors:

 support_vectors = model.support_vectors_
 dual_coefs = model.dual_coef_[0]

Then:

pred = (np.matmul(dual_coefs.reshape(1,589), 
                  rbf_kernel(support_vectors.reshape(589,40),
                             Y=input_array.reshape(1,40), 
                             gamma=model.get_params()['gamma']
                             )
                 )
        + model.intercept_
       )

If the RBF funcion needs to be applied manually, step by step, then:

vrbf = support_vectors.reshape(589,40) - input_array.reshape(1,40)
pred = (np.matmul(dual_coefs.reshape(1,589), 
                  np.diag(np.exp(-model.get_params()['gamma'] * 
                                 np.matmul(vrbf, vrbf.T)
                                )
                         ).reshape(589,1)
                 )
        + model.intercept_
       )

I placed the .reshape() function even where it is not necessary, just to emphasize the shapes for the matrix operations.
These both give the same results as model.predict(input_array)