Example usage for weka.core Instances Instances

List of usage examples for weka.core Instances Instances

  1. HOME
  2. Java
  3. weka
  4. weka.core.*
  5. Instances
  6. Instances

Introduction

In this page you can find the example usage for weka.core Instances Instances.

Prototype

public Instances(String name, ArrayList<Attribute> attInfo, int capacity)

Source Link

Document

Creates an empty set of instances.

Usage

From source file:edu.oregonstate.eecs.mcplan.abstraction.MulticlassRepresenter.java

License:Open Source License

public MulticlassRepresenter(final Classifier classifier, final int Nclasses,
        final FactoredRepresenter<S, ? extends FactoredRepresentation<S>> base_repr) {
    classifier_ = classifier;/*  w  w  w  . j  av  a  2s.co m*/
    this.Nclasses = Nclasses;
    final ArrayList<Attribute> labeled = new ArrayList<Attribute>(base_repr.attributes());
    labeled.add(WekaUtil.createNominalAttribute("__label__", Nclasses));
    headers_ = new Instances("dummy", labeled, 0);
    headers_.setClassIndex(labeled.size() - 1);
}

From source file:edu.oregonstate.eecs.mcplan.abstraction.PairDataset.java

License:Open Source License

public static <S, X extends FactoredRepresentation<S>, A extends VirtualConstructor<A>> Instances makePairDataset(
        final RandomGenerator rng, final int max_pairwise_instances, final Instances single,
        final InstanceCombiner combiner) {
    //      final int max_pairwise = config.getInt( "training.max_pairwise" );
    final ReservoirSampleAccumulator<Instance> negative = new ReservoirSampleAccumulator<Instance>(rng,
            max_pairwise_instances);//from  www. ja  va 2  s . c  o m
    final ReservoirSampleAccumulator<Instance> positive = new ReservoirSampleAccumulator<Instance>(rng,
            max_pairwise_instances);

    for (int i = 0; i < single.size(); ++i) {
        //         if( i % 100 == 0 ) {
        //            System.out.println( "i = " + i );
        //         }
        for (int j = i + 1; j < single.size(); ++j) {
            final Instance ii = single.get(i);
            final Instance ij = single.get(j);
            final int label;
            if (ii.classValue() == ij.classValue()) {
                label = 1;
                if (positive.acceptNext()) {
                    final Instance pair_instance = combiner.apply(ii, ij, label);
                    positive.addPending(pair_instance);
                }
            } else {
                label = 0;
                if (negative.acceptNext()) {
                    final Instance pair_instance = combiner.apply(ii, ij, label);
                    negative.addPending(pair_instance);
                }
            }
        }
    }

    final int N = Math.min(negative.samples().size(), positive.samples().size());
    final String dataset_name = "train_" + combiner.keyword() + "_" + max_pairwise_instances;
    final Instances x = new Instances(dataset_name, combiner.attributes(), 2 * N);
    x.setClassIndex(x.numAttributes() - 1);
    for (final Instance ineg : negative.samples()) {
        x.add(ineg);
    }
    for (final Instance ipos : positive.samples()) {
        x.add(ipos);
    }

    return x;
    //      return new PairDataset( x, combiner );
}

From source file:edu.oregonstate.eecs.mcplan.abstraction.PairDataset.java

License:Open Source License

/**
 * Constructs one positive pair and one negative pair involving each
 * data point in 'single'.//  w  w w.  ja  v  a  2 s. c o m
 * @param rng
 * @param max_pairwise_instances
 * @param single
 * @param combiner
 * @return
 */
public static <S, X extends FactoredRepresentation<S>, A extends VirtualConstructor<A>> PairDataset makeBalancedPairDataset(
        final RandomGenerator rng, final int negative_per_instance, final int positive_per_instance,
        final Instances single, final InstanceCombiner combiner) {
    final int Nnegative = negative_per_instance * single.size();
    final int Npositive = positive_per_instance * single.size();
    //      final int max_pairwise = config.getInt( "training.max_pairwise" );
    final ReservoirSampleAccumulator<Pair<Instance, int[]>> negative = new ReservoirSampleAccumulator<Pair<Instance, int[]>>(
            rng, Nnegative);
    final ReservoirSampleAccumulator<Pair<Instance, int[]>> positive = new ReservoirSampleAccumulator<Pair<Instance, int[]>>(
            rng, Npositive);

    for (int i = 0; i < single.size(); ++i) {
        //         if( i % 100 == 0 ) {
        //            System.out.println( "i = " + i );
        //         }
        for (int j = i + 1; j < single.size(); ++j) {
            final Instance ii = single.get(i);
            final Instance ij = single.get(j);
            final int label;
            if (ii.classValue() == ij.classValue()) {
                label = 1;
                if (positive.acceptNext()) {
                    final Instance pair_instance = combiner.apply(ii, ij, label);
                    positive.addPending(Pair.makePair(pair_instance, new int[] { i, j }));
                }
            } else {
                label = 0;
                if (negative.acceptNext()) {
                    final Instance pair_instance = combiner.apply(ii, ij, label);
                    negative.addPending(Pair.makePair(pair_instance, new int[] { i, j }));
                }
            }
        }
    }

    final int N = Math.min(negative.samples().size(), positive.samples().size());
    final String dataset_name = "train_" + combiner.keyword() + "_" + Nnegative + "x" + Npositive;
    final Instances x = new Instances(dataset_name, combiner.attributes(), Nnegative + Npositive);
    x.setClassIndex(x.numAttributes() - 1);
    final ArrayList<int[]> matches = new ArrayList<int[]>();
    for (final Pair<Instance, int[]> ineg : negative.samples()) {
        WekaUtil.addInstance(x, ineg.first);
        matches.add(ineg.second);
    }
    for (final Pair<Instance, int[]> ipos : positive.samples()) {
        WekaUtil.addInstance(x, ipos.first);
        matches.add(ipos.second);
    }

    return new PairDataset(x, matches, combiner);
}

From source file:edu.oregonstate.eecs.mcplan.abstraction.PairDataset.java

License:Open Source License

/**
 * Constructs one positive pair and one negative pair involving each
 * data point in 'single'./*from w  w  w  .j a va2s  .c  o  m*/
 * @param rng
 * @param max_pairwise_instances
 * @param single
 * @param combiner
 * @return
 */
public static <S, X extends FactoredRepresentation<S>, A extends VirtualConstructor<A>> PairDataset makePlausiblePairDataset(
        final RandomGenerator rng, final int negative_per_instance, final int positive_per_instance,
        final Instances single, final InstanceCombiner combiner,
        final Fn.Function2<Boolean, Instance, Instance> plausible_p) {
    final int Nnegative = negative_per_instance * single.size();
    final int Npositive = positive_per_instance * single.size();
    //      final int max_pairwise = config.getInt( "training.max_pairwise" );
    final ReservoirSampleAccumulator<Pair<Instance, int[]>> negative = new ReservoirSampleAccumulator<Pair<Instance, int[]>>(
            rng, Nnegative);
    final ReservoirSampleAccumulator<Pair<Instance, int[]>> positive = new ReservoirSampleAccumulator<Pair<Instance, int[]>>(
            rng, Npositive);

    for (int i = 0; i < single.size(); ++i) {
        //         if( i % 100 == 0 ) {
        //            System.out.println( "i = " + i );
        //         }
        for (int j = i + 1; j < single.size(); ++j) {
            final Instance ii = single.get(i);
            final Instance ij = single.get(j);

            if (!plausible_p.apply(ii, ij)) {
                //               System.out.println( "Not plausible: " + ii + " != " + ij );
                continue;
            }

            //            System.out.println( "! Plausible: " + ii + " == " + ij );

            final int label;
            if (ii.classValue() == ij.classValue()) {
                label = 1;
                if (positive.acceptNext()) {
                    final Instance pair_instance = combiner.apply(ii, ij, label);
                    positive.addPending(Pair.makePair(pair_instance, new int[] { i, j }));
                }
            } else {
                label = 0;
                if (negative.acceptNext()) {
                    final Instance pair_instance = combiner.apply(ii, ij, label);
                    negative.addPending(Pair.makePair(pair_instance, new int[] { i, j }));
                }
            }
        }
    }

    final int N = Math.min(negative.samples().size(), positive.samples().size());
    final String dataset_name = "train_" + combiner.keyword() + "_" + negative.samples().size() + "x"
            + positive.samples().size();
    final Instances x = new Instances(dataset_name, combiner.attributes(), Nnegative + Npositive);
    x.setClassIndex(x.numAttributes() - 1);
    final ArrayList<int[]> matches = new ArrayList<int[]>();
    for (final Pair<Instance, int[]> ineg : negative.samples()) {
        WekaUtil.addInstance(x, ineg.first);
        matches.add(ineg.second);
    }
    for (final Pair<Instance, int[]> ipos : positive.samples()) {
        WekaUtil.addInstance(x, ipos.first);
        matches.add(ipos.second);
    }

    return new PairDataset(x, matches, combiner);
}

From source file:edu.oregonstate.eecs.mcplan.abstraction.WekaUtil.java

License:Open Source License

public static Instances createEmptyInstances(final String name, final ArrayList<Attribute> attributes) {
    final Instances instances = new Instances(name, attributes, 0);
    instances.setClassIndex(attributes.size() - 1);
    return instances;
}

From source file:edu.oregonstate.eecs.mcplan.abstraction.WekaUtil.java

License:Open Source License

/**
 * Creates an Instances object containing the specified feature vector
 * and with an added "dummy label".//from   w  w w .j  a va  2s .c o m
 * @param attributes
 * @param features
 * @return
 */
public static Instances createSingletonInstances(final List<Attribute> attributes, final double[] features) {
    final ArrayList<Attribute> attr_dummy_label = new ArrayList<Attribute>(attributes);
    attr_dummy_label.add(createBinaryNominalAttribute("__dummy_label__"));
    final double[] features_dummy_label = new double[features.length + 1];
    Fn.memcpy(features_dummy_label, features, features.length);
    final Instance instance = new DenseInstance(1.0, features_dummy_label);
    final Instances x = new Instances("__eval__", attr_dummy_label, 1);
    x.setClassIndex(attr_dummy_label.size() - 1);
    x.add(instance);
    instance.setDataset(x);
    return x;
}

From source file:edu.oregonstate.eecs.mcplan.abstraction.WekaUtil.java

License:Open Source License

public static Instances powerSet(final Instances D, final int n) {
    final Attribute class_attr = D.classAttribute();

    final ImmutableSet.Builder<Integer> b = new ImmutableSet.Builder<Integer>();
    final int Nattr = class_attr != null ? D.numAttributes() - 1 : D.numAttributes();
    for (final int i : Fn.range(1, Nattr)) {
        b.add(i);//  ww  w  .  ja v  a2 s.  com
    }
    final Set<Set<Integer>> index = Sets.powerSet(b.build());

    final ArrayList<Attribute> attributes = new ArrayList<Attribute>();
    for (final Set<Integer> subset : index) {
        if (subset.isEmpty() || subset.size() > n) {
            continue;
        }

        final StringBuilder attr_name = new StringBuilder();
        int count = 0;
        for (final Integer i : subset) {
            if (count++ > 0) {
                attr_name.append("_x_");
            }
            attr_name.append(D.attribute(i).name());
        }

        attributes.add(new Attribute(attr_name.toString()));
    }
    if (class_attr != null) {
        assert (class_attr.isNominal());
        attributes.add(WekaUtil.createNominalAttribute(class_attr.name(), class_attr.numValues()));
    }

    final String Pname = "P" + n + "_" + D.relationName();
    final Instances P = new Instances(Pname, attributes, 0);
    if (class_attr != null) {
        P.setClassIndex(attributes.size() - 1);
    }

    for (final Instance inst : D) {
        final double[] xp = new double[attributes.size()];
        int idx = 0;
        for (final Set<Integer> subset : index) {
            if (subset.isEmpty() || subset.size() > n) {
                continue;
            }

            double p = 1.0;
            for (final Integer i : subset) {
                p *= inst.value(i);
            }
            xp[idx++] = p;
        }
        if (class_attr != null) {
            xp[idx++] = inst.classValue();
        }

        WekaUtil.addInstance(P, new DenseInstance(inst.weight(), xp));
    }

    return P;
}

From source file:edu.oregonstate.eecs.mcplan.abstraction.WekaUtil.java

License:Open Source License

public static Instances allPairwiseProducts(final Instances single, final boolean reflexive,
        final boolean symmetric) {
    final int c = single.classIndex();
    System.out.println("Class attribute = " + c);

    final ArrayList<Attribute> pair_attributes = new ArrayList<Attribute>();
    for (int i = 0; i < single.numAttributes(); ++i) {
        if (i == c) {
            continue;
        }//  ww  w .  ja v  a  2 s .  c  om
        final Attribute ai = single.attribute(i);
        final int j0 = (symmetric ? 0 : i);
        for (int j = j0; j < single.numAttributes(); ++j) {
            if (j == c) {
                continue;
            }
            if (!reflexive && i == j) {
                continue;
            }

            final Attribute aj = single.attribute(j);

            final String name = ai.name() + "_x_" + aj.name();
            pair_attributes.add(new Attribute(name));
        }
    }

    String pair_name = single.relationName();
    pair_name += "_x";
    if (reflexive) {
        pair_name += "r";
    }
    if (symmetric) {
        pair_name += "s";
    }
    pair_name += "_";
    pair_name += single.relationName();
    final Instances result = new Instances(pair_name, pair_attributes, 0);

    for (final Instance inst : single) {
        final double[] xp = new double[pair_attributes.size()];
        int idx = 0;
        for (int i = 0; i < single.numAttributes(); ++i) {
            if (i == c) {
                continue;
            }
            final double xi = inst.value(i);
            final int j0 = (symmetric ? 0 : i);
            for (int j = j0; j < single.numAttributes(); ++j) {
                if (j == c) {
                    continue;
                }
                if (!reflexive && i == j) {
                    continue;
                }
                final double xj = inst.value(j);
                xp[idx++] = xi * xj;
            }
        }
        WekaUtil.addInstance(result, new DenseInstance(inst.weight(), xp));
    }

    return result;
}

From source file:edu.oregonstate.eecs.mcplan.domains.blackjack.AbstractionDiscovery.java

License:Open Source License

private static <X extends FactoredRepresentation<BlackjackState>> Instances makeTrainingSet(
        final SolvedStateAccumulator<X> acc, final ArrayList<Attribute> attributes, final int iter) {
    final int[] num_instances = new int[2];
    final ArrayList<Instance> negative = new ArrayList<Instance>();
    final ArrayList<Instance> positive = new ArrayList<Instance>();
    final ArrayList<String> nominal = new ArrayList<String>();
    nominal.add("0");
    nominal.add("1");
    attributes.add(new Attribute("__label__", nominal));
    final int d = attributes.size() - 1; // Minus 1 for label

    for (int i = 0; i < acc.Phi_.size(); ++i) {
        final double[] phi_i = acc.Phi_.get(i).toArray();
        for (int j = i + 1; j < acc.Phi_.size(); ++j) {
            final double[] phi_j = acc.Phi_.get(j).toArray();
            final double[] phi_labeled = new double[d + 1];
            for (int k = 0; k < d; ++k) {
                phi_labeled[k] = Math.abs(phi_i[k] - phi_j[k]);
            }// www  .jav  a2 s .  c  o  m
            final int label;
            if (acc.actions_.get(i).equals(acc.actions_.get(j))) {
                label = 1;
            } else {
                label = 0;
            }
            final double weight = 1.0; // TODO: Weights?
            final String label_string = Integer.toString(label);
            phi_labeled[d] = label; //attributes.get( label_index ).indexOfValue( label_string );

            num_instances[label] += 1;

            final Instance instance = new DenseInstance(weight, phi_labeled);
            if (label == 0) {
                negative.add(instance);
            } else {
                positive.add(instance);
            }
        }
    }
    System.out.println("num_instances = " + Arrays.toString(num_instances));
    final Instances x = new Instances("train" + iter, attributes, negative.size() + positive.size());
    x.setClassIndex(d);
    x.addAll(negative);
    x.addAll(positive);

    return x;
}

From source file:edu.oregonstate.eecs.mcplan.domains.frogger.FroggerRepresentationConverter.java

License:Open Source License

public static Instances absoluteToRelative(final FroggerParameters params, final Instances src,
        final int vision) {
    final ArrayList<Attribute> attributes = new ArrayList<Attribute>();
    attributes.add(new Attribute("x"));
    attributes.add(new Attribute("y"));
    for (int i = vision; i >= -vision; --i) {
        for (int j = -vision; j <= vision; ++j) {
            if (i == 0 && j == 0) {
                continue;
            }/* ww  w  .j a v  a2s.  c  om*/

            final String name = "car_x" + (j >= 0 ? "+" : "") + j + "_y" + (i >= 0 ? "+" : "") + i;
            attributes.add(new Attribute(name));
        }
    }
    attributes.add(src.classAttribute());

    final Instances dest = new Instances(src.relationName() + "_relative", attributes, src.size());
    for (final Instance inst : src) {
        final double[] phi = new double[attributes.size()];
        int idx = 0;

        final int x = (int) inst.value(0);
        final int y = (int) inst.value(1);
        phi[idx++] = x;
        phi[idx++] = y;

        for (int i = vision; i >= -vision; --i) {
            for (int j = -vision; j <= vision; ++j) {
                if (i == 0 && j == 0) {
                    continue;
                }

                final int xoff = x + j;
                final int yoff = y + i;

                if (xoff >= 0 && xoff < params.road_length && yoff >= 1 && yoff <= params.lanes) {
                    final int car = (int) inst.value(2 + (yoff - 1) * params.road_length + xoff);
                    phi[idx] = car; // s.grid[dy][dx] == Tile.Car ? 1.0 : 0.0; // fv[2 + (dy-1)*road_length + dx]
                }
                idx += 1;
            }
        }

        phi[idx++] = inst.classValue();
        assert (idx == phi.length);

        WekaUtil.addInstance(dest, new DenseInstance(inst.weight(), phi));
    }

    return dest;
}