code: def _post_load_init(self):
      degree = (c_int * 1)()
      gamma = (c_float * 1)()
      coef0 = (c_float * 1)()
      probability = (c_int * 1)()
      kernel = (c_char * 20)()
      thundersvm.init_model_param(
          kernel,
          degree,
          gamma,
          coef0,
          probability,
          c_void_p(self.model),
      )
      n_classes = (c_int * 1)()
      thundersvm.get_n_classes(c_void_p(self.model), n_classes)
      self.n_classes = n_classes[0]
      n_support_ = (c_int * self.n_classes)()
      thundersvm.get_support_classes(
          n_support_, self.n_classes, c_void_p(self.model)
      )
      self.n_support_ = np.frombuffer(
          n_support_, dtype=np.int32
      ).astype(int)
      self.n_sv = thundersvm.n_sv(c_void_p(self.model))
  
      n_feature = (c_int * 1)()
      thundersvm.get_sv_max_index(c_void_p(self.model), n_feature)
      self.n_features = n_feature[0]
      csr_row = (c_int * (self.n_sv + 1))()
      csr_col = (c_int * (self.n_sv * self.n_features))()
      csr_data = (c_float * (self.n_sv * self.n_features))()
      data_size = (c_int * 1)()
      sv_indices = (c_int * self.n_sv)()
      thundersvm.get_sv(
          csr_row,
          csr_col,
          csr_data,
          data_size,
          sv_indices,
          c_void_p(self.model),
      )
      self.row = np.frombuffer(csr_row, dtype=np.int32)
      self.col = np.frombuffer(csr_col, dtype=np.int32)[: data_size[0]]
      self.data = np.frombuffer(csr_data, dtype=np.float32)[
          : data_size[0]
      ]
      self.support_vectors_ = sp.csr_matrix(
          (self.data, self.col, self.row)
      )
      # if self._sparse == False:
      #     self.support_vectors_ = self.support_vectors_.toarray(order = 'C')
      self.support_ = np.frombuffer(sv_indices, dtype=np.int32)
      dual_coef = (c_float * ((self.n_classes - 1) * self.n_sv))()
      thundersvm.get_coef(
          dual_coef, self.n_classes, self.n_sv, c_void_p(self.model)
      )
      self.dual_coef_ = (
          np.frombuffer(dual_coef, dtype=np.float32)
          .astype(float)
          .reshape((self.n_classes - 1, self.n_sv))
      )
  
      rho_size = int(self.n_classes * (self.n_classes - 1) / 2)
      self.n_binary_model = rho_size
      rho = (c_float * rho_size)()
      thundersvm.get_rho(rho, rho_size, c_void_p(self.model))
      self.intercept_ = np.frombuffer(rho, dtype=np.float32).astype(
          float
      )
  
      if self.kernel == "linear":
          coef = (c_float * (self.n_binary_model * self.n_features))()
          thundersvm.get_linear_coef(
              coef,
              self.n_binary_model,
              self.n_features,
              c_void_p(self.model),
          )
          self.coef_ = (
              np.frombuffer(coef, dtype=np.float32)
              .astype(float)
              .reshape((self.n_binary_model, self.n_features))
          )
  
      self.kernel = kernel.value.decode()
      self.degree = degree[0]
      if gamma[0] != 0.0:
          self.gamma = gamma[0]
      self.coef0 = coef0[0]
      self.probability = probability[0]
  
imports: from sklearn.base import BaseEstimator
  from sklearn.base import RegressorMixin, ClassifierMixin
  import numpy
  import scipy.sparse
  from sklearn.utils import check_X_y, column_or_1d, check_array
  from sklearn.utils.validation import _num_samples
  from ctypes import *
  from os import path, curdir
  from sys import platform
label_desc: Use image node_id 18 for calling the SvmModel obj's underlying member method code with example usage: obj._post_load_init() without return types