"Integrating RapidMiner into your java application"

package rapidminer_5x;

import com.rapidminer.repository.RepositoryLocation;
import com.rapidminer.tools.OperatorService ;
import com.rapidminer.ProcessContext;
import com.rapidminer.RapidMiner;
import com.rapidminer.RapidMiner.ExecutionMode;
import com.rapidminer.Process;
import com.rapidminer.operator.*;
import com.rapidminer.operator.io.ModelWriter;
import com.rapidminer.operator.io.RepositorySource;
import com.rapidminer.operator.learner.functions.neuralnet.NeuralNetLearner;
import com.rapidminer.operator.ports.*;
import com.rapidminer.operator.validation.XValidation;

public class Test {	

	/**
	 * @param argv
	 */
	public static void main (String [] argv) {

		try {

			//Set the execution mode in which to run RM
			RapidMiner.setExecutionMode(ExecutionMode.COMMAND_LINE);
			// Initialize Rapidminer			
			RapidMiner.init();	
		}

		catch (Exception e) {
			e.printStackTrace();

		}

		// Create a process
		Process process = new Process();		

		try {

			/*Create a location entry for the repository that 
			 * is to be used as input
			 */
			RepositoryLocation location = new RepositoryLocation
			("//Samples/data/Iris");

			String loc = process.makeRelativeRepositoryLocation(location);

			// create input operator
			Operator retrieve =
			OperatorService.createOperator(RepositorySource.class);			


			/*Set the parameter of the operator to the location of
			 *the repository entry 
			 */			
			retrieve.setParameter("repository_entry", loc);  					

			//Create the neural network operator
			NeuralNetLearner neuralNet = 
				OperatorService.createOperator(NeuralNetLearner.class);

			//Create the model writer
			Operator modelWriter =
				OperatorService.createOperator(ModelWriter.class);

			//Create the XValidation operator chain
			XValidation xvalidation = OperatorService.createOperator(XValidation.class);

			xvalidation.setExpanded(true);

			//Set the parameters for model writer
			modelWriter.setParameter("model_file", 
					"D:/Bhavya/RapidMiner/test2.mod");

			modelWriter.setParameter("output_type","XML");

			//Create the output port of the retrieve operator
			OutputPort retrieveOutput = retrieve
			.getOutputPorts().getPortByName("output");

			//Create the input port of XValidation
			InputPort xvalidationInput = xvalidation.getInputPorts()
			.getPortByName("training");

			//Create the input port of Neural Net
			InputPort neuralNetInput = neuralNet.getInputPorts()
			.getPortByName("training set");

			//Create the output port of Neural Net
			OutputPort neuralNetOutput = neuralNet.getOutputPorts()
			.getPortByName("model");

			//Create the input port of Model Writer
			InputPort modelWriterInput = modelWriter.getInputPorts()
			.getPortByName("input");

			//Create the output port of Model Writer
			OutputPort modelWriterOutput = modelWriter.getOutputPorts()
			.getPortByName("through");

			xvalidation.shouldAutoConnect(neuralNetInput);

			xvalidation.getSubprocess(0).addOperator(neuralNet);
			xvalidation.getSubprocess(0).addOperator(modelWriter);
			//ExecutionUnit exec = 

			//xvalidation.getSubprocess(0).autoWireSingle(neuralNet, null, true, true);

			//Connect the output port of Retrieve to the input port 
			//of xvalidation						
			retrieveOutput.connectTo(xvalidationInput);					
			//retrieveOutput.connectTo(neuralNetInput);
			neuralNetInput = neuralNet.getExampleSetInputPort();							

			// add operator to process
			process.getRootOperator().getSubprocess(0)
			.addOperator(retrieve);
			process.getRootOperator().getSubprocess(0)
			.addOperator(xvalidation);	

			//Connect the output of neural net to the input of model writer
			neuralNetOutput.connectTo(modelWriterInput);			

			//Connect the input of xvalidation to the input of neural net
//			IOObject data = xvalidationInput.getAnyDataOrNull();
//											

			/*
			//IOOb
		    //xvalidation.execute();
			IOObject input = xvalidationInput.getData();
			neuralNetInput.receive(input);
			neuralNet.shouldAutoConnect(xvalidationInput); 			
			 * 
			 * 
			 */

			//print process setup
			System.out.println(process.getRootOperator().createProcessTree(0));

			// perform process
			process.run();	

			xvalidationInput.receive(retrieveOutput.getData());
			IOObject data = xvalidationInput.getData();
			neuralNetInput.receive(data);		

			}

			catch(Exception e) {
				e.printStackTrace();
			}		
	}
}

• used ImprovedNeuralNetLearner.class as learner since the NeuralNetLearner in your code has not sufficient capabilities for the iris-dataset
• added the %{a} - macro to the model-writer-filename so the model of every training step is written
• shifted some code - blocks around for the sake of readability

package rapidminer_5x;

import com.rapidminer.Process;
import com.rapidminer.RapidMiner;
import com.rapidminer.RapidMiner.ExecutionMode;
import com.rapidminer.operator.ExecutionUnit;
import com.rapidminer.operator.ModelApplier;
import com.rapidminer.operator.Operator;
import com.rapidminer.operator.io.ModelWriter;
import com.rapidminer.operator.io.RepositorySource;
import com.rapidminer.operator.learner.functions.neuralnet.ImprovedNeuralNetLearner;
import com.rapidminer.operator.performance.PerformanceEvaluator;
import com.rapidminer.operator.validation.XValidation;
import com.rapidminer.repository.RepositoryLocation;
import com.rapidminer.tools.OperatorService;

public class Test {

	private static Operator createRetrievalOperator(Process parentProcess)
			throws Exception {
		RepositoryLocation location = new RepositoryLocation(
				"//Samples/data/Iris");

		String loc = parentProcess.makeRelativeRepositoryLocation(location);

		// create input operator
		Operator retrieve = OperatorService
				.createOperator(RepositorySource.class);

		/*
		 * Set the parameter of the operator to the location of the repository
		 * entry
		 */
		retrieve.setParameter("repository_entry", loc);
		return retrieve;
	}

	private static Operator createModelWriter() throws Exception {
		// Create the model writer
		Operator modelWriter = OperatorService
				.createOperator(ModelWriter.class);
		// Set the parameters for model writer
		modelWriter.setParameter("model_file", "c:/nn_run_%{a}.mode");

		modelWriter.setParameter("output_type", "XML");

		return modelWriter;
	}

	/**
	 * Connect the output-port <code>fromPortName</code> from Operator
	 * <code>from</code> with the input-port <code>toPortName</code> of Operator
	 * <code>to</code>.
	 */
	private static void connect(Operator from, String fromPortName,
			Operator to, String toPortName) {
		from.getOutputPorts().getPortByName(fromPortName).connectTo(
				to.getInputPorts().getPortByName(toPortName));
	}

	/**
	 * Connect the output-port <code>fromPortName</code> from Subprocess
	 * <code>from</code> with the input-port <code>toPortName</code> of Operator
	 * <code>to</code>.
	 */
	private static void connect(ExecutionUnit from, String fromPortName,
			Operator to, String toPortName) {
		from.getInnerSources().getPortByName(fromPortName).connectTo(
				to.getInputPorts().getPortByName(toPortName));
	}

	/**
	 * Connect the output-port <code>fromPortName</code> from Operator
	 * <code>from</code> with the input-port <code>toPortName</code> of
	 * Subprocess <code>to</code>.
	 */
	private static void connect(Operator from, String fromPortName,
			ExecutionUnit to, String toPortName) {
		from.getOutputPorts().getPortByName(fromPortName).connectTo(
				to.getInnerSinks().getPortByName(toPortName));
	}

	public static void main(String[] argv) throws Exception {
		// init rapidminer
		RapidMiner.setExecutionMode(ExecutionMode.COMMAND_LINE);
		RapidMiner.init();

		// Create a process
		final Process process = new Process();

		// all operators from "left to right"
		final Operator retrieve = createRetrievalOperator(process);

		final XValidation xvalidation = OperatorService
				.createOperator(XValidation.class);
		xvalidation.setParameter(XValidation.PARAMETER_NUMBER_OF_VALIDATIONS,
				Integer.valueOf(2).toString());

		final ImprovedNeuralNetLearner neuralNet = OperatorService
				.createOperator(ImprovedNeuralNetLearner.class);

		final Operator modelWriter = createModelWriter();

		final Operator modelApplier = OperatorService
				.createOperator(ModelApplier.class);

		final Operator performance = OperatorService
				.createOperator(PerformanceEvaluator.class);

		// add operators to the main process and connect them
		process.getRootOperator().getSubprocess(0).addOperator(retrieve);
		process.getRootOperator().getSubprocess(0).addOperator(xvalidation);
		connect(retrieve, "output", xvalidation, "training");

		// xvalidation
		// training part of xvalidation
		xvalidation.getSubprocess(0).addOperator(neuralNet);
		xvalidation.getSubprocess(0).addOperator(modelWriter);

		// create connection within training process: from left to right ...
		connect(xvalidation.getSubprocess(0), "training", neuralNet,
				"training set");
		connect(neuralNet, "model", modelWriter, "input");
		connect(modelWriter, "through", xvalidation.getSubprocess(0), "model");

		// testing part of xvalidation
		xvalidation.getSubprocess(1).addOperator(modelApplier);
		xvalidation.getSubprocess(1).addOperator(performance);

		// create connection within testing process: from left to right ...
		connect(xvalidation.getSubprocess(1), "model", modelApplier, "model");
		connect(xvalidation.getSubprocess(1), "test set", modelApplier,
				"unlabelled data");
		connect(modelApplier, "labelled data", performance, "labelled data");
		connect(performance, "performance", xvalidation.getSubprocess(1),
				"averagable 1");

		// print process setup
		System.out.println(process.getRootOperator().createProcessTree(0));

		// perform process
		process.run();
	}
}