Java ParameterTypeCategory类代码示例

import com.rapidminer.parameter.ParameterTypeCategory; //导入依赖的package包/类
@Override
public List<ParameterType> getParameterTypes() {
	List<ParameterType> types = super.getParameterTypes();

	types.add(new ParameterTypeBoolean(
			PARAMETER_LEAVE_ONE_OUT,
			"Set the number of validations to the number of examples. If set to true, number_of_validations is ignored.",
			false, false));

	ParameterType type = new ParameterTypeInt(PARAMETER_NUMBER_OF_VALIDATIONS,
			"Number of subsets for the crossvalidation.", 2, Integer.MAX_VALUE, 10, false);
	type.registerDependencyCondition(new BooleanParameterCondition(this, PARAMETER_LEAVE_ONE_OUT, false, false));
	types.add(type);

	types.add(new ParameterTypeCategory(PARAMETER_SAMPLING_TYPE, "Defines the sampling type of the cross validation.",
			SplittedExampleSet.SAMPLING_NAMES, SplittedExampleSet.STRATIFIED_SAMPLING, false));

	types.addAll(RandomGenerator.getRandomGeneratorParameters(this));

	return types;
}
 

import com.rapidminer.parameter.ParameterTypeCategory; //导入依赖的package包/类
@Override
public List<ParameterType> getParameterTypes() {
	List<ParameterType> types = super.getParameterTypes();
	types.add(new ParameterTypeInt(PARAMETER_NUMBER_ORIGINAL,
			"The maximum of original attributes added in each generation.", 0, Integer.MAX_VALUE, 2));
	types.add(new ParameterTypeInt(PARAMETER_NUMBER_CONSTRUCTED,
			"The maximum number of attributes constructed in each generation.", 0, Integer.MAX_VALUE, 2));
	types.add(new ParameterTypeString(PARAMETER_UNUSED_FUNCTIONS,
			"Space separated list of functions which are not allowed in arguments for attribute construction."));
	types.add(new ParameterTypeInt(PARAMETER_START_SINUS_BOOST, "Uses a fourier generation in this first generations",
			0, Integer.MAX_VALUE, 0));
	types.add(new ParameterTypeInt(PARAMETER_SEARCH_FOURIER_PEAKS,
			"Use this number of highest frequency peaks for sinus generation.", 0, Integer.MAX_VALUE, 0));
	types.add(new ParameterTypeInt(PARAMETER_ATTRIBUTES_PER_PEAK,
			"Use this number of additional peaks for each found peak.", 1, Integer.MAX_VALUE, 1));
	types.add(new ParameterTypeDouble(PARAMETER_EPSILON, "Use this range for additional peaks for each found peak.", 0,
			Double.POSITIVE_INFINITY, 0.1));
	types.add(new ParameterTypeCategory(PARAMETER_ADAPTION_TYPE, "Use this adaption type for additional peaks.",
			SinusFactory.ADAPTION_TYPES, SinusFactory.GAUSSIAN));
	return types;
}
 

import com.rapidminer.parameter.ParameterTypeCategory; //导入依赖的package包/类
@Override
public List<ParameterType> getParameterTypes() {
	List<ParameterType> types = super.getParameterTypes();
	ParameterType type = new ParameterTypeInt(PARAMETER_NUMBER_OF_FOLDS,
			"The number of folds used for a cross validation evaluation (-1: use simple split ratio).", -1,
			Integer.MAX_VALUE, 10);
	type.setExpert(false);
	types.add(type);
	types.add(new ParameterTypeDouble(PARAMETER_SPLIT_RATIO, "Relative size of the training set", 0.0d, 1.0d, 0.7d));
	types.add(new ParameterTypeCategory(
			PARAMETER_SAMPLING_TYPE,
			"Defines the sampling type of the cross validation (linear = consecutive subsets, shuffled = random subsets, stratified = random subsets with class distribution kept constant)",
			SplittedExampleSet.SAMPLING_NAMES, SplittedExampleSet.STRATIFIED_SAMPLING));

	types.addAll(RandomGenerator.getRandomGeneratorParameters(this));

	types.add(new ParameterTypeBoolean(PARAMETER_USE_EXAMPLE_WEIGHTS,
			"Indicates if example weights should be regarded (use weight 1 for each example otherwise).", true));

	types.add(ROCBias.makeParameterType());
	return types;
}
 

import com.rapidminer.parameter.ParameterTypeCategory; //导入依赖的package包/类
@Override
public List<ParameterType> getParameterTypes() {
	List<ParameterType> types = super.getParameterTypes();
	types.add(new ParameterTypeCategory(PARAMETER_CLASSIFICATION_STRATEGIES,
			"What strategy should be used for multi class classifications?", STRATEGIES, ONE_AGAINST_ALL, false));

	ParameterTypeDouble type = new ParameterTypeDouble(PARAMETER_RANDOM_CODE_MULTIPLICATOR,
			"A multiplicator regulating the codeword length in random code modus.", 1.0d, Double.POSITIVE_INFINITY,
			2.0d, false);
	type.registerDependencyCondition(new EqualTypeCondition(this, PARAMETER_CLASSIFICATION_STRATEGIES, STRATEGIES, true,
			EXHAUSTIVE_CODE, RANDOM_CODE));
	types.add(type);

	types.addAll(RandomGenerator.getRandomGeneratorParameters(this));

	return types;
}
 

import com.rapidminer.parameter.ParameterTypeCategory; //导入依赖的package包/类
/**
 * Adds the parameters "number of iterations" and "model file".
 */
@Override
public List<ParameterType> getParameterTypes() {
	List<ParameterType> types = super.getParameterTypes();
	types.add(new ParameterTypeInt(PARAMETER_MAX_DEPTH, "An upper bound for the number of literals.", 1,
			Integer.MAX_VALUE, 2));
	types.add(new ParameterTypeCategory(PARAMETER_UTILITY_FUNCTION, "The function to be optimized by the rule.",
			UTILITY_FUNCTION_LIST, 0));
	types.add(new ParameterTypeInt(
			PARAMETER_MAX_CACHE,
			"Bounds the number of rules considered per depth to avoid high memory consumption, but leads to incomplete search.",
			1, Integer.MAX_VALUE, 10000));
	types.add(new ParameterTypeBoolean(PARAMETER_RELATIVE_TO_PREDICTIONS,
			"Searches for rules with a maximum difference to the predited label.", false));
	return types;
}
 

import com.rapidminer.parameter.ParameterTypeCategory; //导入依赖的package包/类
@Override
public List<ParameterType> getParameterTypes() {
	List<ParameterType> types = super.getParameterTypes();
	types.add(new ParameterTypeCategory(PARAMETER_DISCOVERY_MODE, "Discovery mode.", DISCOVERY_MODES, 1, false));
	types.add(new ParameterTypeCategory(PARAMETER_UTILITY_FUNCTION, "Utility function.", UtilityFunction.FUNCTIONS,
			UtilityFunction.WRACC));
	types.add(new ParameterTypeDouble(PARAMETER_MIN_UTILITY, "Minimum quality which has to be reached.",
			Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 0.0));
	types.add(new ParameterTypeInt(PARAMETER_K_BEST_RULES, "Report the k best rules.", 1, Integer.MAX_VALUE, 10, false));
	types.add(new ParameterTypeCategory(PARAMETER_RULE_GENERATION, "Determines which rules are generated.",
			RULE_GENERATION_MODES, Hypothesis.POSITIVE_AND_NEGATIVE_RULES));
	types.add(new ParameterTypeInt(PARAMETER_MAX_DEPTH, "Maximum depth of BFS.", 0, Integer.MAX_VALUE, 5));
	types.add(new ParameterTypeDouble(PARAMETER_MIN_COVERAGE,
			"Only consider rules which exceed the given coverage threshold.", 0, 1, 0));
	types.add(new ParameterTypeInt(PARAMETER_MAX_CACHE,
			"Bounds the number of rules which are evaluated (only the most supported rules are used).", -1,
			Integer.MAX_VALUE, -1));
	return types;
}
 

import com.rapidminer.parameter.ParameterTypeCategory; //导入依赖的package包/类
@Override
public List<ParameterType> getParameterTypes() {
	List<ParameterType> types = super.getParameterTypes();
	types.add(new ParameterTypeCategory(PARAMETER_JOIN_TYPE, "Specifies which join should be executed.", JOIN_TYPES,
			JOIN_TYPE_INNER, false));
	types.add(new ParameterTypeBoolean(PARAMETER_USE_ID, "Indicates if the id attribute is used for join.", true, false));
	ParameterType joinAttributes = new ParameterTypeList(PARAMETER_JOIN_ATTRIBUTES,
			"The attributes which shall be used for join. Attributes which shall be matched must be of the same type.",
			new ParameterTypeAttribute(PARAMETER_LEFT_ATTRIBUTE_FOR_JOIN,
					"The attribute in the left example set to be used for the join.", getInputPorts().getPortByName(
							LEFT_EXAMPLE_SET_INPUT), true), new ParameterTypeAttribute(
					PARAMETER_RIGHT_ATTRIBUTE_FOR_JOIN,
					"The attribute in the left example set to be used for the join.", getInputPorts().getPortByName(
							RIGHT_EXAMPLE_SET_INPUT), true), false);
	joinAttributes.registerDependencyCondition(new BooleanParameterCondition(this, PARAMETER_USE_ID, true, false));

	types.add(joinAttributes);

	ParameterType keepBoth = new ParameterTypeBoolean(
			PARAMETER_KEEP_BOTH_JOIN_ATTRIBUTES,
			"If checked, both columns of a join pair will be kept. Usually this is unneccessary since both attributes are identical.",
			false, true);
	types.add(keepBoth);

	return types;
}
 

import com.rapidminer.parameter.ParameterTypeCategory; //导入依赖的package包/类
/** Returns a list with all parameter types of this model. */
@Override
public List<ParameterType> getParameterTypes() {
	List<ParameterType> types = super.getParameterTypes();
	types.add(new ParameterTypeCategory(PARAMETER_NORMALIZATION_METHOD, "Select the normalization method.",
			NORMALIZATION_METHODS, 0));
	int i = 0;
	for (NormalizationMethod method : METHODS) {
		for (ParameterType type : method.getParameterTypes(this)) {
			type.registerDependencyCondition(new EqualTypeCondition(this, PARAMETER_NORMALIZATION_METHOD,
					NORMALIZATION_METHODS, true, new int[] { i }));
			types.add(type);
		}
		i++;
	}
	return types;
}
 

import com.rapidminer.parameter.ParameterTypeCategory; //导入依赖的package包/类
@Override
public List<ParameterType> getParameterTypes() {
	List<ParameterType> types = super.getParameterTypes();
	types.add(new ParameterTypeAttribute(PARAMETER_GROUP_ATTRIBUTE,
			"Attribute that groups the examples which form one example after pivoting.", getExampleSetInputPort(), false));
	types.add(new ParameterTypeAttribute(PARAMETER_INDEX_ATTRIBUTE,
			"Attribute which differentiates examples inside a group.", getExampleSetInputPort(), false));
	types.add(new ParameterTypeBoolean(PARAMETER_CONSIDER_WEIGHTS,
			"Determines whether weights will be kept and aggregated or ignored.", true, false));
	ParameterType type = new ParameterTypeCategory(PARAMETER_WEIGHT_AGGREGATION,
			"Specifies how example weights are aggregated in the groups.",
			AbstractAggregationFunction.KNOWN_AGGREGATION_FUNCTION_NAMES, AbstractAggregationFunction.SUM, false);
	type.registerDependencyCondition(new BooleanParameterCondition(this, PARAMETER_CONSIDER_WEIGHTS, true, true));
	types.add(type);

	types.add(new ParameterTypeBoolean(PARAMETER_SKIP_CONSTANT_ATTRIBUTES,
			"Skips attributes if their value never changes within a group.", true));
	types.add(new ParameterTypeCategory(PARAMETER_DATAMANAGEMENT, "Determines, how the data is represented internally.",
			DataRowFactory.TYPE_NAMES, DataRowFactory.TYPE_DOUBLE_ARRAY));
	return types;
}
 

import com.rapidminer.parameter.ParameterTypeCategory; //导入依赖的package包/类
@Override
public List<ParameterType> getParameterTypes() {
	List<ParameterType> types = super.getParameterTypes();
	// omitt first (most general) type
	String[] valueTypes = new String[Ontology.VALUE_TYPE_NAMES.length - 1];
	for (int i = 0; i < valueTypes.length; i++) {
		valueTypes[i] = Ontology.VALUE_TYPE_NAMES[i + 1];
	}
	ParameterType type = new ParameterTypeCategory(PARAMETER_SKIP_FEATURES_OF_TYPE,
			"All features of this type will be deselected.", valueTypes, 0);
	type.setExpert(false);
	types.add(type);

	String[] exceptionValueTypes = new String[valueTypes.length + 1];
	exceptionValueTypes[0] = "none";
	System.arraycopy(valueTypes, 0, exceptionValueTypes, 1, valueTypes.length);
	types.add(new ParameterTypeCategory(PARAMETER_EXCEPT_FEATURES_OF_TYPE,
			"All features of this type will not be deselected.", exceptionValueTypes, 0));
	return types;
}
 

import com.rapidminer.parameter.ParameterTypeCategory; //导入依赖的package包/类
@Override
public List<ParameterType> getParameterTypes() {
	List<ParameterType> types = super.getParameterTypes();
	// omitt first (most general) type
	String[] blockTypes = new String[Ontology.BLOCK_TYPE_NAMES.length - 1];
	for (int i = 0; i < blockTypes.length; i++) {
		blockTypes[i] = Ontology.BLOCK_TYPE_NAMES[i + 1];
	}

	ParameterType type = new ParameterTypeCategory(PARAMETER_SKIP_FEATURES_OF_TYPE,
			"All features of this type will be deselected off.", blockTypes, 0);
	type.setExpert(false);
	types.add(type);

	String[] exceptionBlockTypes = new String[blockTypes.length + 1];
	exceptionBlockTypes[0] = "none";
	System.arraycopy(blockTypes, 0, exceptionBlockTypes, 1, blockTypes.length);
	types.add(new ParameterTypeCategory(PARAMETER_EXCEPT_FEATURES_OF_TYPE,
			"All features of this type will not be deselected.", exceptionBlockTypes, 0));
	return types;
}
 

import com.rapidminer.parameter.ParameterTypeCategory; //导入依赖的package包/类
@Override
public List<ParameterType> getParameterTypes() {
	List<ParameterType> types = super.getParameterTypes();
	String[] functionNames = getFunctionNames();
	ParameterType type = new ParameterTypeCategory(PARAMETER_DEFAULT,
			"Function to apply to all columns that are not explicitly specified by parameter 'columns'.", functionNames,
			getDefaultFunction());
	type.setExpert(false);
	types.add(type);
	ParameterTypeStringCategory categories = new ParameterTypeStringCategory(
			"replace_with",
			"Selects the function, which is used to determine the replacement for the missing values of this attribute.",
			functionNames, getFunctionNames()[getDefaultColumnFunction()], false);
	categories.setEditable(false);
	types.add(new ParameterTypeList(PARAMETER_COLUMNS, "List of replacement functions for each column.",
			new ParameterTypeAttribute("attribute", "Specifies the attribute, which missing values are replaced.",
					getExampleSetInputPort()), categories));
	return types;
}
 

import com.rapidminer.parameter.ParameterTypeCategory; //导入依赖的package包/类
@Override
public List<ParameterType> getParameterTypes() {
	List<ParameterType> parameterTypes = super.getParameterTypes();

	parameterTypes.add(new ParameterTypeCategory(PARAMETER_SOURCE_TYPE,
			"Choose wether to open a file, a URL or a repository entry.", SOURCE_TYPES, SOURCE_TYPE_FILE, true));

	ParameterTypeFile parameterTypeFile = new ParameterTypeFile(PARAMETER_FILENAME, "File to open", null, true, false);
	parameterTypeFile.registerDependencyCondition(new EqualTypeCondition(this, PARAMETER_SOURCE_TYPE, SOURCE_TYPES,
			true, SOURCE_TYPE_FILE));
	parameterTypes.add(parameterTypeFile);

	ParameterTypeString parameterTypeUrl = new ParameterTypeString(PARAMETER_URL, "URL to open", true, false);
	parameterTypeUrl.registerDependencyCondition(new EqualTypeCondition(this, PARAMETER_SOURCE_TYPE, SOURCE_TYPES, true,
			SOURCE_TYPE_URL));
	parameterTypes.add(parameterTypeUrl);

	ParameterTypeRepositoryLocation parameterTypeRepositoryLocation = new ParameterTypeRepositoryLocation(
			PARAMETER_REPOSITORY_LOCATION, "repository entry to open", true);
	parameterTypeRepositoryLocation.setExpert(false);
	parameterTypeRepositoryLocation.registerDependencyCondition(new EqualTypeCondition(this, PARAMETER_SOURCE_TYPE,
			SOURCE_TYPES, true, SOURCE_TYPE_REPOSITORY));
	parameterTypes.add(parameterTypeRepositoryLocation);

	return parameterTypes;
}
 

import com.rapidminer.parameter.ParameterTypeCategory; //导入依赖的package包/类
@Override
public List<ParameterType> getParameterTypes() {
	List<ParameterType> types = super.getParameterTypes();

	types.add(new ParameterTypeString(
			PARAMETER_DIRECTORY,
			"This parameter specifies the directory where the entry will be stored inside the archive file. Specify it in the form 'my/sub/directory', or leave it empty to store the entry in the root folder.",
			"", false));
	types.add(new ParameterTypeBoolean(
			PARAMETER_OVERRIDE_COMPRESSION_LEVEL,
			"This parameter allows to override the default compression	level of the archive file object for the entries created by this operator. The default level is set by the Create Archive File operator	that created the archive file object. This is useful, if you are adding	pre-compressed files to	the archive, such as zip files, jar files etc. These files cannot be further compressed, so you can save some execution time by setting the compression level for new entries of this kind to a low value.",
			false, true));
	ParameterType type = new ParameterTypeCategory(
			PARAMETER_COMPRESSION_LEVEL,
			"The compression level of the newly created entries is specified through this parameter.	In general, higher compression levels result also in a higher runtime.",
			COMPRESSION_LEVELS, COMPRESSION_LEVEL_DEFAULT, true);
	type.registerDependencyCondition(new BooleanParameterCondition(this, PARAMETER_OVERRIDE_COMPRESSION_LEVEL, true,
			true));
	types.add(type);

	return types;
}
 

import com.rapidminer.parameter.ParameterTypeCategory; //导入依赖的package包/类
@Override
public List<ParameterType> getParameterTypes() {
	List<ParameterType> types = super.getParameterTypes();

	types.add(new ParameterTypeCategory(
			PARAMETER_BUFFER_TYPE,
			"Defines where the buffer for the archive file will be created. A memory buffered archive file will usually perform faster in terms of execution time, but the complete archive file must be kept in memory, which can lead to problems if large files or a large amount of files is added to the archive.",
			BUFFER_TYPES, BUFFER_TYPE_FILE, true));
	types.add(new ParameterTypeBoolean(
			PARAMETER_USE_DEFAULT_COMPRESSION_LEVEL,
			"This parameter allows you to override the default compression level. The default compression level depends on the host machine, but usually offers a reasonable trade-off between execution time and compression factor.",
			true, true));
	ParameterType type = new ParameterTypeCategory(
			PARAMETER_COMPRESSION_LEVEL,
			"The default compression level of the created zip file is specified by this parameter. This level may be overridden in the subsequent Add Entry to Zip File operators on a per-entry base. A compression level of 0 stands for no compression, whereas the highest level 9 means best compression. In general, higher compression levels result also in a higher runtime.",
			COMPRESSION_LEVELS, COMPRESSION_LEVEL_DEFAULT, true);
	type.registerDependencyCondition(new BooleanParameterCondition(this, PARAMETER_USE_DEFAULT_COMPRESSION_LEVEL, true,
			false));
	types.add(type);

	return types;
}