Java DataDefinition类代码示例

import org.deidentifier.arx.DataDefinition; //导入依赖的package包/类
/**
 * Returns an array representation of the dataset. Extracts all attributes that are defined
 * as quasi-identifiers in the given definition 
 * 
 * @param handle
 * @param definition
 * @return
 */
public String[][] toArray(DataHandle handle, DataDefinition definition) {
    
    List<Integer> indices = new ArrayList<Integer>();
    for (String attribute : definition.getQuasiIdentifyingAttributes()) {
        indices.add(handle.getColumnIndexOf(attribute));
    }
    
    List<String[]> list = new ArrayList<String[]>();
    Iterator<String[]> iter = handle.iterator();
    iter.next(); // Skip header
    for (;iter.hasNext();) {
        String[] input = iter.next();
        String[] output = new String[indices.size()];
        int i = 0;
        for (int index : indices) {
            output[i++] = input[index];
        }
        list.add(output);
    }
    return list.toArray(new String[list.size()][]);
}
 

import org.deidentifier.arx.DataDefinition; //导入依赖的package包/类
@Override
protected void initializeInternal(final DataManager manager,
                                  final DataDefinition definition, 
                                  final Data input, 
                                  final GeneralizationHierarchy[] hierarchies, 
                                  final ARXConfiguration config) {
    super.initializeInternal(manager, definition, input, hierarchies, config);

    minHeight = 0;
    maxHeight = 0;
    Set<String> genQis = definition.getQuasiIdentifiersWithGeneralization();
    for (String genQi : genQis) {
        minHeight += definition.getMinimumGeneralization(genQi);
        maxHeight += definition.getMaximumGeneralization(genQi);
    }
}
 

import org.deidentifier.arx.DataDefinition; //导入依赖的package包/类
@Override
protected void initializeInternal(final DataManager manager,
                                  final DataDefinition definition, 
                                  final Data input, 
                                  final GeneralizationHierarchy[] hierarchies, 
                                  final ARXConfiguration config) {
    
    // Prepare super
    super.initializeInternal(manager, definition, input, hierarchies, config);

    // Compute cardinalities
    RowSet subset = super.getSubset(config);
    
    // Cardinalities
    this.cardinalities = new Cardinalities(input, subset, hierarchies);
    
    // Distinct values
    this.values = new int[hierarchies.length][][];
    for (int i=0; i<values.length; i++) {
        values[i] = new int[hierarchies[i].getHeight()][];
        for (int j=0; j<values[i].length; j++){
            values[i][j] = hierarchies[i].getDistinctValues(j);
        }
    }
}
 

import org.deidentifier.arx.DataDefinition; //导入依赖的package包/类
@Override
protected void initializeInternal(final DataManager manager,
                                  final DataDefinition definition,
                                  final Data input,
                                  final GeneralizationHierarchy[] hierarchies,
                                  final ARXConfiguration config) {

    super.initializeInternal(manager, definition, input, hierarchies, config);

    // Compute domain shares
    this.shares =  manager.getDomainShares();
    this.config = config.getCostBenefitConfiguration();
    this.modelRisk = new RiskModelCostBenefit(this.config);
    this.maximalPayout = new QualityMetadata<Double>(MAXIMAL_PAYOUT, super.getNumRecords(config, input) * this.config.getPublisherBenefit());
            
    // Calculate MaxIL
    this.maxIL = MetricSDNMEntropyBasedInformationLoss.getMaximalEntropyBasedInformationLoss(this.shares, super.getMicroaggregationDomainSizes());
}
 

import org.deidentifier.arx.DataDefinition; //导入依赖的package包/类
@Override
protected void initializeInternal(final DataManager manager,
                                  final DataDefinition definition, 
                                  final Data input, 
                                  final GeneralizationHierarchy[] hierarchies, 
                                  final ARXConfiguration config) {
    
    super.initializeInternal(manager, definition, input, hierarchies, config);

    this.upper = super.getUpperBounds();
    
    // Compute a reasonable min & max
    double[] min = new double[hierarchies.length];
    Arrays.fill(min, 0d);
    
    double[] max = new double[hierarchies.length];
    Arrays.fill(max, 1d);
    
    super.setMax(max);
    super.setMin(min);
}
 

import org.deidentifier.arx.DataDefinition; //导入依赖的package包/类
@Override
protected void initializeInternal(final DataManager manager,
                                  final DataDefinition definition,
                                  final Data input,
                                  final GeneralizationHierarchy[] hierarchies,
                                  final ARXConfiguration config) {

    // Prepare weights
    super.initializeInternal(manager, definition, input, hierarchies, config);

    // Compute domain shares
    this.shares =  manager.getDomainShares();

    // Calculate MaxIL
    this.maxIL = getMaximalEntropyBasedInformationLoss(this.shares, super.getMicroaggregationDomainSizes());
}
 

import org.deidentifier.arx.DataDefinition; //导入依赖的package包/类
@Override
protected void initializeInternal(final DataManager manager,
                                  final DataDefinition definition, 
                                  final Data input, 
                                  final GeneralizationHierarchy[] ahierarchies, 
                                  final ARXConfiguration config) {
    
    this.precomputed = true;
    double rows = input.getDataLength();
    for (GeneralizationHierarchy hierarchy : ahierarchies) {
        double share = (double)hierarchy.getDistinctValues()[0] / rows;
        if (share > threshold) {
            this.precomputed = false;
            break;
        }
    }
    
    if (precomputed) {
        precomputedMetric.initializeInternal(manager, definition, input, ahierarchies, config);
    } else {
        defaultMetric.initializeInternal(manager, definition, input, ahierarchies, config);
    }
}
 

import org.deidentifier.arx.DataDefinition; //导入依赖的package包/类
@Override
protected void initializeInternal(final DataManager manager,
                                  final DataDefinition definition, 
                                  final Data input, 
                                  final GeneralizationHierarchy[] hierarchies, 
                                  final ARXConfiguration config) {
    
    // Prepare weights
    super.initializeInternal(manager, definition, input, hierarchies, config);

    // Determine total number of tuples
    this.tuples = (double)super.getNumRecords(config, input);
    
    // Save domain shares
    this.shares = manager.getDomainShares();
    
    // Min and max
    double[] min = new double[getDimensions()];
    Arrays.fill(min, 0d);
    double[] max = new double[getDimensions()];
    Arrays.fill(max, 1d);
    super.setMin(min);
    super.setMax(max);
}
 

import org.deidentifier.arx.DataDefinition; //导入依赖的package包/类
@Override
protected void initializeInternal(final DataManager manager,
                                  final DataDefinition definition, 
                                  final Data input, 
                                  final GeneralizationHierarchy[] hierarchies, 
                                  final ARXConfiguration config) {
    super.initializeInternal(manager, definition, input, hierarchies, config);
    
    // Min and max
    double[] min = new double[hierarchies.length];
    double[] max = new double[min.length];

    for (int i=0; i<hierarchies.length; i++){
        String attribute = hierarchies[i].getName();
        min[i] = definition.getMinimumGeneralization(attribute);
        max[i] = definition.getMaximumGeneralization(attribute);
    }
    
    setMin(min);
    setMax(max);
}
 

import org.deidentifier.arx.DataDefinition; //导入依赖的package包/类
@Override
protected void initializeInternal(final DataManager manager,
                                  final DataDefinition definition, 
                                  final Data input, 
                                  final GeneralizationHierarchy[] hierarchies, 
                                  final ARXConfiguration config) {
    
    this.tuples = (double) getNumRecords(config, input);

    // Handle microaggregation
    this.microaggregationFunctions = manager.getMicroaggregationFunctions();
    this.microaggregationStartIndex = manager.getMicroaggregationStartIndex();
    this.microaggregationDomainSizes = manager.getMicroaggregationDomainSizes();
    if (!config.isUtilityBasedMicroaggregation() || !isAbleToHandleMicroaggregation()) {
        this.microaggregationFunctions = new DistributionAggregateFunction[0];
        this.microaggregationDomainSizes = new int[0];
    }
}
 

import org.deidentifier.arx.DataDefinition; //导入依赖的package包/类
@Override
protected void initializeInternal(final DataManager manager,
                                  final DataDefinition definition, 
                                  final Data input, 
                                  final GeneralizationHierarchy[] hierarchies, 
                                  final ARXConfiguration config) {
    
    super.initializeInternal(manager, definition, input, hierarchies, config);

    // Prepare
    double gFactor = super.getGeneralizationFactor();
    double sFactor = super.getSuppressionFactor();
    
    // Compute a reasonable minimum & maximum
    double[] min = new double[hierarchies.length];
    Arrays.fill(min, 0d);
    
    double[] max = new double[hierarchies.length];
    for (int i=0; i<max.length; i++) {
        max[i] = (2d * input.getDataLength() * log2(input.getDataLength())) * Math.max(gFactor, sFactor);
    }
    
    super.setMax(max);
    super.setMin(min);
}
 

import org.deidentifier.arx.DataDefinition; //导入依赖的package包/类
@Override
protected void initializeInternal(final DataManager manager,
                                  final DataDefinition definition, 
                                  final Data input, 
                                  final GeneralizationHierarchy[] hierarchies, 
                                  final ARXConfiguration config) {
    super.initializeInternal(manager, definition, input, hierarchies, config);

    // Initialize maximum levels
    height = new int[hierarchies.length];
    for (int j = 0; j < height.length; j++) {
        height[j] = hierarchies[j].getArray()[0].length - 1;
    }
    
    int rowCount = super.getNumRecords(config, input);
    this.cells = (double)rowCount * (double)input.getHeader().length;
}
 

import org.deidentifier.arx.DataDefinition; //导入依赖的package包/类
/**
   * Writes the data definition to the file.
   *
   * @param config
   * @param prefix
   * @param zip
   * @throws IOException
   */
  private void writeDefinition(final ModelConfiguration config,
                               final String prefix,
                               final ZipOutputStream zip) throws IOException {
  	
  	// Obtain definition
  	DataDefinition definition = null;
  	if (config == model.getInputConfig()) definition = model.getInputDefinition();
  	else definition = model.getOutputDefinition();
  	
  	// Store
if (definition != null) {
	zip.putNextEntry(new ZipEntry(prefix + "definition.xml")); //$NON-NLS-1$
	final Writer w = new OutputStreamWriter(zip);
	w.write(toXML(config, config.getInput().getHandle(), definition));
	w.flush();
}
  }
 

import org.deidentifier.arx.DataDefinition; //导入依赖的package包/类
/**
 * Creates a new instance.
 * 
 * @param file
 * @param syntax
 * @param input
 * @param definition
 * @param config
 * @param result
 * @param transformation
 * @param output
 */
public WorkerCreateCertificate(String path,
                               CSVSyntax syntax,
                               DataHandle input,
                               DataDefinition definition,
                               ARXConfiguration config,
                               ARXResult result,
                               ARXNode transformation,
                               DataHandle output,
                               Model model) {
    this.syntax = syntax;
    this.path = path;
    this.input = input;
    this.definition = definition;
    this.config = config;
    this.result = result;
    this.transformation = transformation;
    this.output = output;
    this.model = model;
}
 

import org.deidentifier.arx.DataDefinition; //导入依赖的package包/类
/**
 * Returns the size of the solution space
 * @return
 * @throws IOException 
 */
private static int getSolutionSpaceSize(BenchmarkDataset dataset) throws IOException {
    int size = 1;
    DataDefinition definition = BenchmarkSetup.getData(dataset).getDefinition();
    for (String qi : definition.getQuasiIdentifiersWithGeneralization()) {
        size *= definition.getHierarchy(qi)[0].length;
    }
    return size;
}