Bag Algorithm
The Bag Algorithm, also known as Bagging or Bootstrap Aggregating, is an ensemble learning technique that aims to increase the overall performance and stability of a machine learning model. It was introduced by Leo Breiman in 1996 as a method to enhance the performance of decision trees, but it can be applied to any type of base learning algorithm. The main idea behind the Bag Algorithm is to create multiple training datasets by sampling with replacement from the original data, then train separate models on each of these new datasets, and finally aggregate the outputs of these models to make a final prediction.
To implement the Bag Algorithm, one starts by generating multiple bootstrap samples from the original training data. Each bootstrap sample is created by randomly selecting instances from the original dataset, allowing duplicates. This results in a diverse set of training data for each base model, which helps reduce overfitting and improve generalization. Next, a base learning algorithm, such as a decision tree or a neural network, is trained on each of these bootstrap samples. Once all models are trained, their predictions are combined in an ensemble, typically through a majority vote for classification problems or by taking the average for regression problems. This process of aggregation reduces the variance of the final predictions, leading to improved accuracy and robustness of the model.
package DataStructures.Bags;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* Collection which does not allow removing elements (only collect and iterate)
*
* @param <Element> - the generic type of an element in this bag
*/
public class Bag<Element> implements Iterable<Element> {
private Node<Element> firstElement; // first element of the bag
private int size; // size of bag
private static class Node<Element> {
private Element content;
private Node<Element> nextElement;
}
/**
* Create an empty bag
*/
public Bag() {
firstElement = null;
size = 0;
}
/**
* @return true if this bag is empty, false otherwise
*/
public boolean isEmpty() {
return firstElement == null;
}
/**
* @return the number of elements
*/
public int size() {
return size;
}
/**
* @param element - the element to add
*/
public void add(Element element) {
Node<Element> oldfirst = firstElement;
firstElement = new Node<>();
firstElement.content = element;
firstElement.nextElement = oldfirst;
size++;
}
/**
* Checks if the bag contains a specific element
*
* @param element which you want to look for
* @return true if bag contains element, otherwise false
*/
public boolean contains(Element element) {
Iterator<Element> iterator = this.iterator();
while (iterator.hasNext()) {
if (iterator.next().equals(element)) {
return true;
}
}
return false;
}
/**
* @return an iterator that iterates over the elements in this bag in arbitrary order
*/
public Iterator<Element> iterator() {
return new ListIterator<>(firstElement);
}
@SuppressWarnings("hiding")
private class ListIterator<Element> implements Iterator<Element> {
private Node<Element> currentElement;
public ListIterator(Node<Element> firstElement) {
currentElement = firstElement;
}
public boolean hasNext() {
return currentElement != null;
}
/**
* remove is not allowed in a bag
*/
@Override
public void remove() {
throw new UnsupportedOperationException();
}
public Element next() {
if (!hasNext())
throw new NoSuchElementException();
Element element = currentElement.content;
currentElement = currentElement.nextElement;
return element;
}
}
/**
* main-method for testing
*/
public static void main(String[] args) {
Bag<String> bag = new Bag<>();
bag.add("1");
bag.add("1");
bag.add("2");
System.out.println("size of bag = " + bag.size());
for (String s : bag) {
System.out.println(s);
}
System.out.println(bag.contains(null));
System.out.println(bag.contains("1"));
System.out.println(bag.contains("3"));
}
}
