package edu.hitsz.c102c.util;
import java.io.Serializable;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import edu.hitsz.c102c.cnn.Layer.Size;
import edu.hitsz.c102c.util.TimedTest.TestTask;
public class Util {
/**
* ¾ØÕó¶ÔÓ¦ÔªËØÏà³ËʱÔÚÿ¸öÔªËØÉϵIJÙ×÷
*
* @author jiqunpeng
*
* ´´½¨Ê±¼ä£º2014-7-9 ÏÂÎç9:28:35
*/
public interface Operator extends Serializable {
public double process(double value);
}
// ¶¨Òåÿ¸öÔªËØvalue¶¼½øÐÐ1-valueµÄ²Ù×÷
public static final Operator one_value = new Operator() {
/**
*
*/
private static final long serialVersionUID = 3752139491940330714L;
@Override
public double process(double value) {
return 1 - value;
}
};
// digmodº¯Êý
public static final Operator digmod = new Operator() {
/**
*
*/
private static final long serialVersionUID = -1952718905019847589L;
@Override
public double process(double value) {
return 1 / (1 + Math.pow(Math.E, -value));
}
};
interface OperatorOnTwo extends Serializable {
public double process(double a, double b);
}
/**
* ¶¨Ò徨Õó¶ÔÓ¦ÔªËØµÄ¼Ó·¨²Ù×÷
*/
public static final OperatorOnTwo plus = new OperatorOnTwo() {
/**
*
*/
private static final long serialVersionUID = -6298144029766839945L;
@Override
public double process(double a, double b) {
return a + b;
}
};
/**
* ¶¨Ò徨Õó¶ÔÓ¦ÔªËØµÄ³Ë·¨²Ù×÷
*/
public static OperatorOnTwo multiply = new OperatorOnTwo() {
/**
*
*/
private static final long serialVersionUID = -7053767821858820698L;
@Override
public double process(double a, double b) {
return a * b;
}
};
/**
* ¶¨Ò徨Õó¶ÔÓ¦ÔªËØµÄ¼õ·¨²Ù×÷
*/
public static OperatorOnTwo minus = new OperatorOnTwo() {
/**
*
*/
private static final long serialVersionUID = 7346065545555093912L;
@Override
public double process(double a, double b) {
return a - b;
}
};
public static void printMatrix(double[][] matrix) {
for (int i = 0; i < matrix.length; i++) {
String line = Arrays.toString(matrix[i]);
line = line.replaceAll(", ", "\t");
System.out.println(line);
}
System.out.println();
}
/**
* ¶Ô¾ØÕó½øÐÐ180¶ÈÐýת,ÊÇÔÚmatrixµÄ¸±±¾Éϸ´ÖÆ£¬²»»á¶ÔÔÀ´µÄ¾ØÕó½øÐÐÐÞ¸Ä
*
* @param matrix
*/
public static double[][] rot180(double[][] matrix) {
matrix = cloneMatrix(matrix);
int m = matrix.length;
int n = matrix[0].length;
// °´ÁжԳƽøÐн»»»
for (int i = 0; i < m; i++) {
for (int j = 0; j < n / 2; j++) {
double tmp = matrix[i][j];
matrix[i][j] = matrix[i][n - 1 - j];
matrix[i][n - 1 - j] = tmp;
}
}
// °´ÐжԳƽøÐн»»»
for (int j = 0; j < n; j++) {
for (int i = 0; i < m / 2; i++) {
double tmp = matrix[i][j];
matrix[i][j] = matrix[m - 1 - i][j];
matrix[m - 1 - i][j] = tmp;
}
}
return matrix;
}
private static Random r = new Random(2);
/**
* Ëæ»ú³õʼ»¯¾ØÕó
*
* @param x
* @param y
* @param b
* @return
*/
public static double[][] randomMatrix(int x, int y, boolean b) {
double[][] matrix = new double[x][y];
int tag = 1;
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
// Ëæ»úÖµÔÚ[-0.05,0.05)Ö®¼ä£¬ÈÃÈ¨ÖØ³õʼ»¯Öµ½ÏС£¬ÓÐÀûÓÚÓÚ±ÜÃâ¹ýÄâºÏ
matrix[i][j] = (r.nextDouble() - 0.05) / 10;
// matrix[i][j] = tag * 0.5;
// if (b)
// matrix[i][j] *= 1.0*(i + j + 2) / (i + 1) / (j + 1);
// tag *= -1;
}
}
// printMatrix(matrix);
return matrix;
}
/**
* Ëæ»ú³õʼ»¯Ò»Î¬ÏòÁ¿
*
* @param len
* @return
*/
public static double[] randomArray(int len) {
double[] data = new double[len];
for (int i = 0; i < len; i++) {
// data[i] = r.nextDouble() / 10 - 0.05;
data[i] = 0;
}
return data;
}
/**
* Ëæ»úÅÅÁеijéÑù£¬Ëæ»ú³éÈ¡batchSize¸ö[0,size)µÄÊé
*
* @param size
* @param batchSize
* @return
*/
public static int[] randomPerm(int size, int batchSize) {
Set set = new HashSet();
while (set.size() < batchSize) {
set.add(r.nextInt(size));
}
int[] randPerm = new int[batchSize];
int i = 0;
for (Integer value : set)
randPerm[i++] = value;
return randPerm;
}
/**
* ¸´ÖƾØÕó
*
* @param matrix
* @return
*/
public static double[][] cloneMatrix(final double[][] matrix) {
final int m = matrix.length;
int n = matrix[0].length;
final double[][] outMatrix = new double[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
outMatrix[i][j] = matrix[i][j];
}
}
return outMatrix;
}
/**
* ¶Ôµ¥¸ö¾ØÕó½øÐвÙ×÷
*
* @param ma
* @param operator
* @return
*/
public static double[][] matrixOp(final double[][] ma, Operator operator) {
final int m = ma.length;
int n = ma[0].length;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
ma[i][j] = operator.process(ma[i][j]);
}
}
return ma;
}
/**
* Á½¸öά¶ÈÏàͬµÄ¾ØÕó¶ÔÓ¦ÔªËØ²Ù×÷,µÃµ½µÄ½á¹û·½·¨mbÖУ¬¼´mb[i][j] = (op_a
* ma[i][j]) op (op_b mb[i][j])
*
* @param ma
* @param mb
* @param operatorB
* ÔÚµÚmb¾ØÕóÉϵIJÙ×÷
* @param operatorA
* ÔÚma¾ØÕóÔªËØÉϵIJÙ×÷
* @return
*
*/
public static double[][] matrixOp(final double[][] ma, final double[][] mb,
final Operator operatorA, final Operator operatorB,
OperatorOnTwo operator) {
final int m = ma.length;
int n = ma[0].length;
if (m != mb.length || n != mb[0].length)
throw new RuntimeException("Á½¸ö¾ØÕó´óС²»Ò»Ö ma.length:" + ma.length
+ " mb.length:" + mb.length);
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
double a = ma[i][j];
if (operatorA != null)
a = operatorA.process(a);
double b = mb[i][j];
if (operatorB != null)
b = operatorB.process(b);
mb[i][j] = operator.process(a, b);
}
}
return mb;
}
/**
* ¿ËÂÞÄÚ¿Ë»ý,¶Ô¾ØÕó½øÐÐÀ©Õ¹
*
* @param matrix
* @param scale
* @return
*/
public static double[][] kronecker(final double[][] matrix, final Size scale) {
final int m = matrix.length;
int n = matrix[0].length;
final double[][] outMatrix = new double[m * scale.x][n * scale.y];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
for (int ki = i * scale.x; ki < (i + 1) * scale.x; ki++) {
for (int kj = j * scale.y; kj < (j + 1) * scale.y; kj++) {
outMatrix[ki][kj] = matrix[i][j];
}
}
}
}
return outMatrix;
}
/**
* ¶Ô¾ØÕó½øÐоùÖµËõС
*
* @param matrix
* @param scaleSize
* @return
*/
public static double[][] scaleMatrix(final double[][] matrix,
final Size scale) {
int m = matrix.length;
int n = matrix[0].length;
final int sm = m / scale.x;
final int sn = n / scale.y;
final double[][] outMatrix = new double[sm][sn];
if (sm * scale.x != m || sn * scale.y != n)
throw new RuntimeException("scale²»ÄÜÕû³ýmatrix");
final int size = scale.x * scale.y;
for (int i = 0; i < sm; i++) {
for (int j = 0; j < sn; j++) {
double sum = 0.0;
for (int si = i * scale.x; si < (i + 1) * scale.x; si++) {
for (int sj = j * scale.y; sj < (j + 1) * scale.y; sj++) {
sum += matrix[si][sj];
}
}
outMatrix[i][j] = sum / size;
}
}
return outMatrix;
}
/**
* ¼ÆËãfullģʽµÄ¾í»ý
*
* @param matrix
* @param kernel
* @return
*/
public static double[][] convnFull(double[][] matrix,
final double[][] kernel) {
int m = matrix.length;
int n = matrix[0].length;
final int km = kernel.length;
final int kn = kernel[0].length;
// À©Õ¹¾ØÕó
final double[][] extendMatrix = new double[m + 2 * (km - 1)][n + 2
* (kn - 1)];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++)
extendMatrix[i + km - 1][j + kn - 1] = matrix[i][j];
}
return convnValid(extendMatrix, kernel);
}
/**
* ¼ÆËãvalidģʽµÄ¾í»ý
*
* @param matrix
* @param kernel
* @return
*/
public static double[][] convnValid(final double[][] matrix,
double[][] kernel) {
//kernel = rot180(kernel);
int m = matrix.length;
int n = matrix[0].length;
final int km = kernel.length;
final int kn = kernel[0].length;
// ÐèÒª×ö¾í»ýµÄÁÐÊý
int kns = n - kn + 1;
// ÐèÒª×ö¾í»ýµÄÐÐÊý
final int kms = m - km + 1;
// ½á¹û¾ØÕó
final double[][] outMatrix = new double[kms][kns];
for (int i = 0; i < kms; i++) {
for (int j = 0; j < kns; j++) {
double sum = 0.0;
for (int ki = 0; ki < km; ki++) {
for (int kj = 0; kj < kn; kj++)
sum += matrix[i + ki][j + kj] * kernel[ki][kj];
}
outMatrix[i][j] = sum;
}
}
return outMatrix;
}
/**
* Èýά¾ØÕóµÄ¾í»ý,ÕâÀïÒªÇóÁ½¸ö¾ØÕóµÄһάÏàͬ
*
* @param matrix
* @param kernel
* @return
*/
public static double[][] convnValid(final double[][][][] matrix,
int mapNoX, double[][][][] kernel, int mapNoY) {
int m = matrix.length;
int n = matrix[0][mapNoX].length;
int h = matrix[0][mapNoX][0].length;
int km = kernel.length;
int kn = kernel[0][mapNoY].length;
int kh = kernel[0][mapNoY][0].length;
int kms = m - km + 1;
int kns = n - kn + 1;
int khs = h - kh + 1;
if (matrix.length != kernel.length)
throw new RuntimeException("¾ØÕóÓë¾í»ýºËÔÚµÚһάÉϲ»Í¬");
// ½á¹û¾ØÕó
final double[][][] outMatrix = new double[kms][kns][khs];
for (int i = 0; i < kms; i++) {
for (int j = 0; j < kns; j++)
for (int k = 0; k < khs; k++) {
double sum = 0.0;
for (int ki = 0; ki < km; ki++) {
for (int kj = 0; kj < kn; kj++)
for (int kk = 0; kk < kh; kk++) {
sum += matrix[i + ki][mapNoX][j + kj][k + kk]
* kernel[ki][mapNoY][kj][kk];
}
}
outMatrix[i][j][k] = sum;
}
}
return outMatrix[0];
}
public static double sigmod(double x) {
return 1 / (1 + Math.pow(Math.E, -x));
}
/**
* ¶Ô¾ØÕóÔªËØÇóºÍ
*
* @param error
* @return ×¢ÒâÕâ¸öÇóºÍºÜ¿ÉÄÜ»áÒç³ö
*/
public static double sum(double[][] error) {
int m = error.length;
int n = error[0].length;
double sum = 0.0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
sum += error[i][j];
}
}
return sum;
}
/**
* ¶Ôerrors[...][j]ÔªËØÇóºÍ
*
* @param errors
* @param j
* @return
*/
public static double[][] sum(double[][][][] errors, int j) {
int m = errors[0][j].length;
int n = errors[0][j][0].length;
double[][] result = new double[m][n];
for (int mi = 0; mi < m; mi++) {
for (int nj = 0; nj < n; nj++) {
double sum = 0;
for (int i = 0; i < errors.length; i++)
sum += errors[i][j][mi][nj];
result[mi][nj] = sum;
}
}
return result;
}
public static int binaryArray2int(double[] array) {
int[] d = new int[array.length];
for (int i = 0; i < d.length; i++) {
if (array[i] >= 0.500000001)
d[i] = 1;
else
d[i] = 0;
}
String s = Arrays.toString(d);
String binary = s.substring(1, s.length() - 1).replace(", ", "");
int data = Integer.parseInt(binary, 2);
return data;
}
/**
* ²âÊÔ¾í»ý,²âÊÔ½á¹û£º4ºËϲ¢·¢²¢Ðеľí»ýÌá¸ß²»µ½2±¶
*/
private static void testConvn() {
int count = 1;
double[][] m = new double[5][5];
for (int i = 0; i < m.length; i++)
for (int j = 0; j < m[0].length; j++)
m[i][j] = count++;
double[][] k = new double[3][3];
for (int i = 0; i < k.length; i++)
for (int j = 0; j < k[0].length; j++)
k[i][j] = 1;
double[][] out;
// out= convnValid(m, k);
Util.printMatrix(m);
out = convnFull(m, k);
Util.printMatrix(out);
// System.out.println();
// out = convnFull(m, Util.rot180(k));
// Util.printMatrix(out);
}
private static void testScaleMatrix() {
int count = 1;
double[][] m = new double[16][16];
for (int i = 0; i < m.length; i++)
for (int j = 0; j < m[0].length; j++)
m[i][j] = count++;
double[][] out = scaleMatrix(m, new Size(2, 2));
Util.printMatrix(m);
Util.printMatrix(out);
}
private static void testKronecker() {
int count = 1;
double[][] m = new double[5][5];
for (int i = 0; i < m.length; i++)
for (int j = 0; j < m[0].length; j++)
m[i][j] = count++;
double[][] out = kronecker(m, new Size(2, 2));
Util.printMatrix(m);
System.out.println();
Util.printMatrix(out);
}
private static void testMatrixProduct() {
int count = 1;
double[][] m = new double[5][5];
for (int i = 0; i < m.length; i++)
for (int j = 0; j < m[0].length; j++)
m[i][j] = count++;
double[][] k = new double[5][5];
for (int i = 0; i < k.length; i++)
for (int j = 0; j < k[0].length; j++)
k[i][j] = j;
Util.printMatrix(m);
Util.printMatrix(k);
double[][] out = matrixOp(m, k, new Operator() {
/**
*
*/
private static final long serialVersionUID = -680712567166604573L;
@Override
public double process(double value) {
return value - 1;
}
}, new Operator() {
/**
*
*/
private static final long serialVersionUID = -6335660830579545544L;
@Override
public double process(double value) {
return -1 * value;
}
}, multiply);
Util.printMatrix(out);
}
private static void testCloneMatrix() {
int count = 1;
double[][] m = new double[5][5];
for (int i = 0; i < m.length; i++)
for (int j = 0; j < m[0].length; j++)
m[i][j] = count++;
double[][] out = cloneMatrix(m);
Util.printMatrix(m);
Util.printMatrix(out);
}
public static void testRot180() {
double[][] matrix = { { 1, 2, 3, 4 }, { 4, 5, 6, 7 }, { 7, 8, 9, 10 } };
printMatrix(matrix);
rot180(matrix);
System.out.println();
printMatrix(matrix);
}
public static void main(String[] args) {
// new TimedTest(new TestTask() {
//
// @Override
// public void process() {
// testConvn();
// // testScaleMatrix();
// // testKronecker();
// // testMatrixProduct();
// // testCloneMatrix();
// }
// }, 1).test();
// ConcurenceRunner.stop();
System.out.println(sigmod(0.727855957917715));
Double a = 1.0;
int b = 1;
System.out.println(a.equals(b));
}
/**
* È¡×î´óµÄÔªËØµÄϱê
*
* @param out
* @return
*/
public static int getMaxIndex(double[] out) {
double max = out[0];
int index = 0;
for (int i = 1; i < out.length; i++)
if (out[i] > max) {
max = out[i];
index = i;
}
return index;
}
public static String fomart(double[] data) {
StringBuilder sb = new StringBuilder("[");
for (double each : data)
sb.append(String.format("%4f,", each));
sb.append("]");
return sb.toString();
}
}
Ads help maintain this website.