Java INDArray.columns方法代码示例

import org.nd4j.linalg.api.ndarray.INDArray; //导入方法依赖的package包/类
public Result run(KieMLContainer kc, Model model, Input input) {
	Result prediction = null;
	List<ModelParam> params = model.getParams();
	if(params == null) {
		throw new IllegalArgumentException("Parameters to configure the input parsing are required!!");
	}
	String transformerName = ParamsUtil.getRequiredStringParam(params, "transformerName");
	Transformer transformer = TransformerFactory.get(transformerName);
	INDArray image = transformer.transform(params, input);
	InputStream isModel = kc.getModelBinInputStream(model);
	INDArray output = getOutput(isModel, image);
	prediction = new Result();
	prediction.setText(output.toString());
	prediction.setPredictions(new HashMap<>());
	for (int i = 0; i < output.columns(); i++) {
		if(output.getDouble(i) == 0d) { 
			continue;
		}
		prediction.getPredictions().put(model.getLabels().get(i), output.getDouble(i));
	}
	return prediction;
}
 

import org.nd4j.linalg.api.ndarray.INDArray; //导入方法依赖的package包/类
private static double[][] getDoubles(INDArray matrix) {
  double[][] data = new double[matrix.rows()][matrix.columns()];
  for (int i = 0; i < data.length; i++) {
    for (int j = 0; j < data[0].length; j++) {
      data[i][j] = matrix.getDouble(i, j);
    }
  }
  return data;
}
 

import org.nd4j.linalg.api.ndarray.INDArray; //导入方法依赖的package包/类
private String toCsv(DataSetIterator it, List<Integer> labels, int[] shape) {
    if (it.numExamples() != labels.size()) {
        throw new IllegalStateException(
                String.format("numExamples == %d != labels.size() == %d",
                        it.numExamples(), labels.size()));
    }

    StringBuffer sb = new StringBuffer();
    int l = 0;

    while (it.hasNext()) {
        INDArray features = it.next(1).getFeatures();

        if (!(Arrays.equals(features.shape(), shape))) {
            throw new IllegalStateException(String.format("wrong shape: got %s, expected",
                    Arrays.toString(features.shape()), Arrays.toString(shape)));
        }

        // Prepend the label
        sb.append(labels.get(l)).append(": ");
        l++;

        for (int i=0; i<features.columns(); i++) {
            sb.append(features.getColumn(i));

            if (i < features.columns()-1) {
                sb.append(", ");
            }
        }

        sb.append("\n");
    }

    return sb.toString();
}
 

import org.nd4j.linalg.api.ndarray.INDArray; //导入方法依赖的package包/类
private boolean isTransitive(double[] ilpSolution, int n) {

		double[][] adjacencyMatrix = new double[n][n];
		int k = 0;
		for (int i = 0; i < n; i++) {
			adjacencyMatrix[i][i] = 1;
			for (int j = i + 1; j < n; j++) {
				adjacencyMatrix[i][j] = ilpSolution[k];
				adjacencyMatrix[j][i] = ilpSolution[k];
				k++;
			}
		}

		INDArray m = new NDArray(adjacencyMatrix);
		INDArray m2 = m.mmul(m);

		System.out.println(m);

		for (int i = 0; i < m.rows(); i++) {
			for (int j = 0; j < m.columns(); j++) {
				if (m2.getDouble(i, j) > 0 && m.getDouble(i, j) == 0) {
					System.out.println(i + " " + j + " " + m2.getDouble(i, j) + " " + m.getDouble(i, j));
					return false;
				}
			}
		}

		return true;
	}
 

import org.nd4j.linalg.api.ndarray.INDArray; //导入方法依赖的package包/类
private static int getMaxValueIndex(INDArray indArray) {
    int maxIndex = 0;
    float maxValue = Float.MIN_VALUE;
    for (int i = 0; i < indArray.columns(); i++) {
        float value = indArray.getFloat(i);
        if (maxValue <= value) {
            maxValue = value;
            maxIndex = i;
        }
    }
    return maxIndex;
}
 

import org.nd4j.linalg.api.ndarray.INDArray; //导入方法依赖的package包/类
public Evaluation (INDArray logits, INDArray labels) {
    this.logits = logits;
    this.labels = labels;
    this.examples = labels.rows();
    this.patterns = labels.columns();
    this.confusionMatrix = new int[patterns][patterns];
    this.precision = new double[patterns];
    this.recall = new double[patterns];
    this.accuracy = 0.0;
}
 

import org.nd4j.linalg.api.ndarray.INDArray; //导入方法依赖的package包/类
private INDArray binomial(INDArray x, Random rng) {
    INDArray y = Nd4j.create(new double[x.rows() * x.columns()], new int[] { x.rows(), x.columns() });
    for (int i = 0; i < x.rows(); i++) {
        for (int j = 0; j < x.columns(); j++) { y.put(i, j, RandomGenerator.binomial(1, x.getDouble(i, j), rng)); }
    }
    return y;
}
 

import org.nd4j.linalg.api.ndarray.INDArray; //导入方法依赖的package包/类
private INDArray getCorruptedInput(INDArray x, double corruptionLevel) {
    INDArray corruptedInput = Nd4j.create(new double[x.rows() * x.columns()], new int[] { x.rows(), x.columns() });
    // add masking noise
    for (int i = 0; i < x.rows(); i++) {
        for (int j = 0; j < x.columns(); j++) {
            double rand_ = rng.nextDouble();
            if (rand_ < corruptionLevel) { corruptedInput.put(i, j, Nd4j.scalar(0.0)); }
            else { corruptedInput.put(i, j, x.getDouble(i, j)); }
        }
    }
    return corruptedInput;
}
 

import org.nd4j.linalg.api.ndarray.INDArray; //导入方法依赖的package包/类
public INDArray outputBinomial (INDArray X) {
    INDArray out = output(X);
    INDArray y = Nd4j.create(new double[out.rows() * out.columns()], new int[] { out.rows(), out.columns() });
    for (int i = 0; i < out.rows(); i++) {
        for (int j = 0; j < out.columns(); j++) {
            double value = RandomGenerator.binomial(1, out.getDouble(i, j), rng);
            y.put(i, j, Nd4j.scalar(value));
        }
    }
    return y;
}