Poor model performance

[quartermaine]

I am exploring incremental learning using the car_evaluation dataset. To implement this, I've taken the following steps:

Data Preparation:
I keep the last 20 lines of the dataset for later use in incremental learning.

Model Configuration:
I create a model using the HoeffdingTreeClassifier with the following parameters:

classifier_tree =  tree.HoeffdingTreeClassifier(
    split_criterion='gini',
    grace_period=500,
    max_depth=150
    )
   model = (
                   imblearn.RandomOverSampler(
                         classifier=multiclass.OneVsRestClassifier(
                                           classifier_tree
                                          ),
                    desired_dist = {'unacc': 1., 'acc': 1., 'good': 1.8, 'vgood': 1.8},
                   # sampling_rate=1,
                  seed=42
        )
    )

The model is then fitted on the training data.

Cross Validation:
I perform cross-validation to check the accuracy of the model:

model_sk.fit(X_transf, y_transf)

then I make cross validation to check the accuracy

scores_sk = model_selection.cross_val_score(model_sk,
                                            X_transf,
                                            y_transf,
                                            scoring='accuracy',
                                            cv=cv,
                                            error_score='raise'
                                           )

Evaluation on Kept Data:
Finally, I evaluate the model on the data that was kept aside:

import sklearn
y_preds = []
f1 = metrics.F1()
acc = metrics.Accuracy()
acc.works_with(model_riv)
precision = metrics.Precision()
recall = metrics.Recall()
for index, row in X_transf_new.iterrows():
  x_dict = row.to_dict()
  y = y_transf_new[index]
  y_pred = model_riv.predict_one(x_dict)
  f1.update(y, y_pred)
  acc.update(y, y_pred)
  precision.update(y, y_pred)
  recall.update(y, y_pred)
  y_preds.append(y_pred)
  model.learn_one(x_dict, y)
print(f'Accuracy Score with {MODEL}: {acc.get():.3f}')
print(f'F1 Score with {MODEL}: {f1.get():.3f}')
print(f'Precision with {MODEL}: {precision.get():.3f}')
print(f'Recall with {MODEL}: {recall.get():.3f}')

Despite these efforts, the accuracy in cross-validation is approximately 0.54%, and the accuracy on the kept data is only 0.06%, which is not acceptable. I'm seeking insights into why this might be happening. Any suggestions or explanations would be greatly appreciated.