How does a trained SVR model predict values?

Question

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.

Answer 1

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)