Introduction

weka.core.UnassignedDatasetException usually appears when an Instance is used before it has been attached to an Instances dataset. Even for unlabeled prediction data, Weka still needs the dataset header because attribute types, attribute order, and class position all come from the dataset definition.

Why an Unlabeled Instance Still Needs a Dataset

In Weka, an Instance by itself is just a row of values. The dataset object supplies the schema:

• how many attributes exist
• which attribute is nominal or numeric
• what the class index is
• what nominal values are allowed

So "unlabeled" does not mean "schema-free". It only means the class value is missing.

If you create an instance and call methods that depend on schema information before assigning a dataset, Weka throws UnassignedDatasetException.

Build the Dataset Header First

The normal pattern is:

1. define the attributes
2. create an empty Instances object as the header
3. set the class index
4. create the new instance
5. assign the header to the instance
6. mark the class value as missing if needed

Example:

1import weka.core.Attribute;
2import weka.core.DenseInstance;
3import weka.core.Instance;
4import weka.core.Instances;
5
6import java.util.ArrayList;
7import java.util.Arrays;
8
9ArrayList<Attribute> attributes = new ArrayList<>();
10attributes.add(new Attribute("x1"));
11attributes.add(new Attribute("x2"));
12attributes.add(new Attribute("class", Arrays.asList("no", "yes")));
13
14Instances header = new Instances("PredictionData", attributes, 0);
15header.setClassIndex(header.numAttributes() - 1);
16
17Instance inst = new DenseInstance(header.numAttributes());
18inst.setDataset(header);
19inst.setValue(0, 1.5);
20inst.setValue(1, 2.5);
21inst.setMissing(header.classIndex());

At this point the instance is unlabeled, but it is valid because it belongs to a dataset with a known schema.

Classification Example

Once the dataset is assigned, the instance can be passed to a trained classifier.

1import weka.classifiers.Classifier;
2
3Classifier model = ...; // already trained
4
5double predictedClassIndex = model.classifyInstance(inst);
6String predictedLabel = header.classAttribute().value((int) predictedClassIndex);
7
8System.out.println(predictedLabel);

The classifier does not only need the raw numbers. It needs the same attribute structure used during training.

Common Failure Pattern

The failure usually looks like this:

1Instance inst = new DenseInstance(3);
2inst.setValue(0, 1.5);
3inst.setValue(1, 2.5);
4// classifier.classifyInstance(inst) fails

This instance has values, but no dataset schema. Weka cannot interpret the row correctly, so it raises the exception.

The fix is not to add a fake label. The fix is to attach the proper dataset header.

Reuse the Training Header for Prediction

A strong pattern is to keep the training dataset header and reuse it for prediction instances. That avoids subtle schema mismatches.

1Instances trainingData = ...;
2Instances header = new Instances(trainingData, 0);
3
4Instance inst = new DenseInstance(header.numAttributes());
5inst.setDataset(header);
6inst.setValue(0, 1.5);
7inst.setValue(1, 2.5);
8inst.setMissing(header.classIndex());

Using the training header ensures that:

• attribute order matches
• nominal definitions match
• the class index matches

That is usually safer than rebuilding attributes manually for each prediction path.

Common Pitfalls

• Thinking an unlabeled instance does not need a dataset schema.
• Creating an Instance and setting values before attaching it to an Instances header.
• Rebuilding the prediction schema manually and getting attribute order or class index wrong.
• Forgetting to mark the class attribute as missing for prediction instances.
• Passing a raw instance to a classifier when the training header is available and should be reused.

Summary

• 'UnassignedDatasetException means the instance was used without a dataset schema.'
• Even unlabeled instances need an Instances header.
• Create or reuse a dataset header, set the class index, then attach it to the instance.
• Mark the class value as missing instead of inventing a placeholder label.
• Reusing the training header is usually the safest prediction-time pattern.