Keyword Spotting Application

.gitignore

@@ -144,3 +144,6 @@ scripts/perftest/fed/temp
 src/test/scripts/functions/iogen/*.raw
 src/test/scripts/functions/pipelines/intermediates/regression/*
 src/test/scripts/functions/pipelines/intermediates/classification/*
+
+venv
+venv/*

fft.dml

@@ -0,0 +1,5 @@
+print("hello")
+M = matrix("0 18 -15 3", rows=1, cols=4)
+[r,i] = fft(M)
+print(toString(r))
+print(toString(i))

scripts/tutorials/keywordSpotting/keywordSpotting.dml

@@ -0,0 +1,34 @@
+
+X = read("tmp/waves.csv", format="csv")
+y = read("tmp/labels.csv", format="csv")
+
+Xy = cbind(X, y)
+num_col = ncol(Xy)
+y_rand = rand(rows=nrow(Xy), cols=1, min=0, max=1, pdf="uniform")
+Xy_shuffled = order(target = cbind(Xy, y_rand), by = num_col + 1)
+Xy_shuffled = Xy_shuffled[,1:num_col] # Remove the random column
+X_shuffled = Xy_shuffled[,1:(num_col-1)] # Features, excluding the last column which is labels
+y_shuffled = Xy_shuffled[,num_col] # Labels, the last column
+
+[X_train, X_test, y_train, y_test] = split(X=X_shuffled, Y=y_shuffled, seed= 13)
+
+[X_train_re, X_train_im] = stft(X_train, 4, 2)
+[X_test_re, X_test_im] = stft(X_test, 4, 2)
+
+X_train_re_sq = X_train_re^2
+X_train_im_sq = X_train_im^2
+
+X_test_re_sq = X_test_re^2
+X_test_im_sq = X_test_im^2
+
+sum_X_train_sq = X_train_re_sq + X_train_im_sq
+sum_X_test_sq = X_test_re_sq + X_test_im_sq
+
+magnitudes_train = sqrt(sum_X_train_sq)
+magnitudes_test = sqrt(sum_X_test_sq)
+
+bias = lm(X=magnitudes_train, y=y_train, reg=1e-1, maxi=10, verbose=TRUE)
+predictions = lmPredict(X=magnitudes_test, B=bias, verbose=FALSE)
+
+accuracy = auc(Y=y_test, P=predictions)
+print(toString(accuracy))

src/main/java/org/apache/sysds/common/Builtins.java

@@ -133,6 +133,8 @@ public enum Builtins {
 	FIT_PIPELINE("fit_pipeline", true),
 	FIX_INVALID_LENGTHS("fixInvalidLengths", true),
 	FIX_INVALID_LENGTHS_APPLY("fixInvalidLengthsApply", true),
+	FFT("fft", false, ReturnType.MULTI_RETURN),
+	FFT_LINEARIZED("fft_linearized", false, ReturnType.MULTI_RETURN),
 	FF_TRAIN("ffTrain", true),
 	FF_PREDICT("ffPredict", true),
 	FLOOR("floor", false),
@@ -154,6 +156,8 @@ public enum Builtins {
 	HOSPITAL_RESIDENCY_MATCH("hospitalResidencyMatch", true),
 	HYPERBAND("hyperband", true),
 	IFELSE("ifelse", false),
+	IFFT("ifft", false, ReturnType.MULTI_RETURN),
+	IFFT_LINEARIZED("ifft_linearized", false, ReturnType.MULTI_RETURN),
 	IMG_MIRROR("img_mirror", true),
 	IMG_MIRROR_LINEARIZED("img_mirror_linearized", true),
 	IMG_BRIGHTNESS("img_brightness", true),
@@ -305,6 +309,7 @@ public enum Builtins {
 	STATSNA("statsNA", true),
 	STRATSTATS("stratstats", true),
 	STEPLM("steplm",true, ReturnType.MULTI_RETURN),
+	STFT("stft", false, ReturnType.MULTI_RETURN),
 	SQRT("sqrt", false),
 	SUM("sum", false),
 	SVD("svd", false, ReturnType.MULTI_RETURN),

src/main/java/org/apache/sysds/hops/FunctionOp.java

@@ -201,6 +201,31 @@ else if ( getFunctionName().equalsIgnoreCase("eigen") ) {
 				long outputValues = OptimizerUtils.estimateSizeExactSparsity(getOutputs().get(1).getDim1(), 1, 1.0);
 				return outputVectors+outputValues; 
 			}
+			else if ( getFunctionName().equalsIgnoreCase("fft") ) {
+				long outputRe = OptimizerUtils.estimateSizeExactSparsity(getOutputs().get(0).getDim1(), getOutputs().get(0).getDim2(), 1.0);
+				long outputIm = OptimizerUtils.estimateSizeExactSparsity(getOutputs().get(1).getDim1(), getOutputs().get(1).getDim2(), 1.0);
+				return outputRe+outputIm;
+			}
+			else if ( getFunctionName().equalsIgnoreCase("ifft") ) {
+				long outputRe = OptimizerUtils.estimateSizeExactSparsity(getOutputs().get(0).getDim1(), getOutputs().get(0).getDim2(), 1.0);
+				long outputIm = OptimizerUtils.estimateSizeExactSparsity(getOutputs().get(1).getDim1(), getOutputs().get(1).getDim2(), 1.0);
+				return outputRe+outputIm;
+			}
+			else if ( getFunctionName().equalsIgnoreCase("fft_linearized") ) {
+				long outputRe = OptimizerUtils.estimateSizeExactSparsity(getOutputs().get(0).getDim1(), getOutputs().get(0).getDim2(), 1.0);
+				long outputIm = OptimizerUtils.estimateSizeExactSparsity(getOutputs().get(1).getDim1(), getOutputs().get(1).getDim2(), 1.0);
+				return outputRe+outputIm;
+			}
+			else if ( getFunctionName().equalsIgnoreCase("ifft_linearized") ) {
+				long outputRe = OptimizerUtils.estimateSizeExactSparsity(getOutputs().get(0).getDim1(), getOutputs().get(0).getDim2(), 1.0);
+				long outputIm = OptimizerUtils.estimateSizeExactSparsity(getOutputs().get(1).getDim1(), getOutputs().get(1).getDim2(), 1.0);
+				return outputRe+outputIm;
+			}
+			else if ( getFunctionName().equalsIgnoreCase("stft") ) {
+				long outputRe = OptimizerUtils.estimateSizeExactSparsity(getOutputs().get(0).getDim1(), getOutputs().get(0).getDim2(), 1.0);
+				long outputIm = OptimizerUtils.estimateSizeExactSparsity(getOutputs().get(1).getDim1(), getOutputs().get(1).getDim2(), 1.0);
+				return outputRe+outputIm;
+			}
 			else if ( getFunctionName().equalsIgnoreCase("lstm") || getFunctionName().equalsIgnoreCase("lstm_backward") ) {
 				// TODO: To allow for initial version to always run on the GPU
 				return 0; 
@@ -250,6 +275,26 @@ else if ( getFunctionName().equalsIgnoreCase("eigen")) {
 				return OptimizerUtils.estimateSizeExactSparsity(getInput().get(0).getDim1(), getInput().get(0).getDim2(), 1.0) 
 						+ 3*OptimizerUtils.estimateSizeExactSparsity(getInput().get(0).getDim1(), 1, 1.0); 
 			}
+			else if ( getFunctionName().equalsIgnoreCase("fft") ) {
+				// 2 matrices of size same as the input
+				return 2*OptimizerUtils.estimateSizeExactSparsity(getInput().get(0).getDim1(), getInput().get(0).getDim2(), 1.0);
+			}
+			else if ( getFunctionName().equalsIgnoreCase("ifft") ) {
+				// 2 matrices of size same as the input
+				return 2*OptimizerUtils.estimateSizeExactSparsity(getInput().get(0).getDim1(), getInput().get(0).getDim2(), 1.0);
+			}
+			else if ( getFunctionName().equalsIgnoreCase("fft_linearized") ) {
+				// 2 matrices of size same as the input
+				return 2*OptimizerUtils.estimateSizeExactSparsity(getInput().get(0).getDim1(), getInput().get(0).getDim2(), 1.0);
+			}
+			else if ( getFunctionName().equalsIgnoreCase("ifft_linearized") ) {
+				// 2 matrices of size same as the input
+				return 2*OptimizerUtils.estimateSizeExactSparsity(getInput().get(0).getDim1(), getInput().get(0).getDim2(), 1.0);
+			}
+			else if ( getFunctionName().equalsIgnoreCase("stft") ) {
+				// 2 matrices of size same as the input
+				return 2*OptimizerUtils.estimateSizeExactSparsity(getInput().get(0).getDim1(), getInput().get(0).getDim2(), 1.0);
+			}
 			else if (getFunctionName().equalsIgnoreCase("batch_norm2d") || getFunctionName().equalsIgnoreCase("batch_norm2d_backward") ||
 					getFunctionName().equalsIgnoreCase("batch_norm2d_train") || getFunctionName().equalsIgnoreCase("batch_norm2d_test")) {
 				return 0; 

src/main/java/org/apache/sysds/parser/BuiltinFunctionExpression.java

@@ -355,6 +355,230 @@ public void validateExpression(MultiAssignmentStatement stmt, HashMap<String, Da
 
 			break;
 		}
+		case FFT: {
+			checkNumParameters(1);
+			checkMatrixParam(getFirstExpr());
+
+			DataIdentifier fftOut1 = (DataIdentifier) getOutputs()[0];
+			DataIdentifier fftOut2 = (DataIdentifier) getOutputs()[1];
+
+			// TODO: Add Validation
+			// if (getFirstExpr().getOutput().getDim2() != 1 ||
+			// getFirstExpr().getOutput().getDim2() != 2) {
+			// raiseValidateError("Eigen Decomposition can only be done on a square matrix.
+			// Input matrix is rectangular (rows=" + getFirstExpr().getOutput().getDim1() +
+			// ", cols="+ getFirstExpr().getOutput().getDim2() +")", conditional);
+			// }
+
+			// Output1 - FFT Values
+			fftOut1.setDataType(DataType.MATRIX);
+			fftOut1.setValueType(ValueType.FP64);
+			fftOut1.setDimensions(getFirstExpr().getOutput().getDim1(), getFirstExpr().getOutput().getDim2());
+			fftOut1.setBlocksize(getFirstExpr().getOutput().getBlocksize());
+
+			// Output2 - FFT Vectors
+			fftOut2.setDataType(DataType.MATRIX);
+			fftOut2.setValueType(ValueType.FP64);
+			fftOut2.setDimensions(getFirstExpr().getOutput().getDim1(), getFirstExpr().getOutput().getDim2());
+			fftOut2.setBlocksize(getFirstExpr().getOutput().getBlocksize());
+
+			break;
+
+		}
+		case IFFT: {
+			Expression expressionTwo = getSecondExpr();
+			checkNumParameters(getSecondExpr() != null ? 2 : 1);
+			checkMatrixParam(getFirstExpr());
+			if (expressionTwo != null)
+				checkMatrixParam(getSecondExpr());
+
+			// setup output properties
+			DataIdentifier ifftOut1 = (DataIdentifier) getOutputs()[0];
+			DataIdentifier ifftOut2 = (DataIdentifier) getOutputs()[1];
+
+			// TODO: Add Validation
+			// if (getFirstExpr().getOutput().getDim2() != 1 ||
+			// getFirstExpr().getOutput().getDim2() != 2) {
+			// raiseValidateError("Eigen Decomposition can only be done on a square matrix.
+			// Input matrix is rectangular (rows=" + getFirstExpr().getOutput().getDim1() +
+			// ", cols="+ getFirstExpr().getOutput().getDim2() +")", conditional);
+			// }
+
+			// Output1 - ifft Values
+			ifftOut1.setDataType(DataType.MATRIX);
+			ifftOut1.setValueType(ValueType.FP64);
+			ifftOut1.setDimensions(getFirstExpr().getOutput().getDim1(), getFirstExpr().getOutput().getDim2());
+			ifftOut1.setBlocksize(getFirstExpr().getOutput().getBlocksize());
+
+			// Output2 - ifft Vectors
+			ifftOut2.setDataType(DataType.MATRIX);
+			ifftOut2.setValueType(ValueType.FP64);
+			ifftOut2.setDimensions(getFirstExpr().getOutput().getDim1(), getFirstExpr().getOutput().getDim2());
+			ifftOut2.setBlocksize(getFirstExpr().getOutput().getBlocksize());
+
+			break;
+		}
+		case FFT_LINEARIZED: {
+
+			Expression expressionOne = getFirstExpr();
+			Expression expressionTwo = getSecondExpr();
+
+			if (expressionOne == null) {
+				raiseValidateError("The first argument to " + _opcode + " cannot be null.", false, LanguageErrorCodes.INVALID_PARAMETERS);
+			}
+
+			else if (expressionOne.getOutput() == null || expressionOne.getOutput().getDim1() == 0 || expressionOne.getOutput().getDim2() == 0) {
+				raiseValidateError("The first argument to " + _opcode + " cannot be an empty matrix.", false, LanguageErrorCodes.INVALID_PARAMETERS);
+			}
+
+			else if (expressionTwo != null) {
+				raiseValidateError("Too many arguments. This FFT_LINEARIZED implementation is only defined for real inputs.", false, LanguageErrorCodes.INVALID_PARAMETERS);
+			}
+
+			else if (!isPowerOfTwo(expressionOne.getOutput().getDim2())) {
+				raiseValidateError("This FFT_LINEARIZED implementation is only defined for matrices with columns that are powers of 2.", false, LanguageErrorCodes.INVALID_PARAMETERS);
+			}
+
+			checkNumParameters(1);
+			checkMatrixParam(getFirstExpr());
+
+			// setup output properties
+			DataIdentifier fftOut1 = (DataIdentifier) getOutputs()[0];
+			DataIdentifier fftOut2 = (DataIdentifier) getOutputs()[1];
+
+			// TODO: Add Validation
+			// if (getFirstExpr().getOutput().getDim2() != 1 ||
+			// getFirstExpr().getOutput().getDim2() != 2) {
+			// raiseValidateError("Eigen Decomposition can only be done on a square matrix.
+			// Input matrix is rectangular (rows=" + getFirstExpr().getOutput().getDim1() +
+			// ", cols="+ getFirstExpr().getOutput().getDim2() +")", conditional);
+			// }
+
+			// Output1 - FFT Values
+			fftOut1.setDataType(DataType.MATRIX);
+			fftOut1.setValueType(ValueType.FP64);
+			fftOut1.setDimensions(getFirstExpr().getOutput().getDim1(), getFirstExpr().getOutput().getDim2());
+			fftOut1.setBlocksize(getFirstExpr().getOutput().getBlocksize());
+
+			// Output2 - FFT Vectors
+			fftOut2.setDataType(DataType.MATRIX);
+			fftOut2.setValueType(ValueType.FP64);
+			fftOut2.setDimensions(getFirstExpr().getOutput().getDim1(), getFirstExpr().getOutput().getDim2());
+			fftOut2.setBlocksize(getFirstExpr().getOutput().getBlocksize());
+
+			break;
+		}
+		case IFFT_LINEARIZED: {
+			Expression expressionTwo = getSecondExpr();
+			Expression expressionOne = getFirstExpr();
+
+			if (expressionOne == null) {
+				raiseValidateError("The first argument to " + _opcode + " cannot be null.", false, LanguageErrorCodes.INVALID_PARAMETERS);
+			}
+
+			else if (expressionOne.getOutput() == null || expressionOne.getOutput().getDim1() == 0 || expressionOne.getOutput().getDim2() == 0) {
+				raiseValidateError("The first argument to " + _opcode + " cannot be an empty matrix.", false, LanguageErrorCodes.INVALID_PARAMETERS);
+			}
+
+			else if (expressionTwo != null){
+				if(expressionTwo.getOutput() == null || expressionTwo.getOutput().getDim1() == 0 || expressionTwo.getOutput().getDim2() == 0) {
+					raiseValidateError("The second argument to " + _opcode + " cannot be an empty matrix. Provide either only a real matrix or a filled real and imaginary one.", false, LanguageErrorCodes.INVALID_PARAMETERS);
+				}
+			}
+
+			checkNumParameters(expressionTwo != null ? 2 : 1);
+			checkMatrixParam(expressionOne);
+			if(expressionTwo != null && expressionOne != null){
+				checkMatrixParam(expressionTwo);
+				if(expressionOne.getOutput().getDim1() != expressionTwo.getOutput().getDim1() || expressionOne.getOutput().getDim2() != expressionTwo.getOutput().getDim2())
+					raiseValidateError("The real and imaginary part of the provided matrix are of different dimensions.", false);
+				else if (!isPowerOfTwo(expressionTwo.getOutput().getDim2())) {
+					raiseValidateError("This IFFT_LINEARIZED implementation is only defined for matrices with columns that are powers of 2.", false, LanguageErrorCodes.INVALID_PARAMETERS);
+				}
+			}
+			else if(expressionOne != null){
+				if (!isPowerOfTwo(expressionOne.getOutput().getDim2())) {
+					raiseValidateError("This IFFT_LINEARIZED implementation is only defined for matrices with columns that are powers of 2.", false, LanguageErrorCodes.INVALID_PARAMETERS);
+				}
+			}
+
+
+			DataIdentifier ifftOut1 = (DataIdentifier) getOutputs()[0];
+			DataIdentifier ifftOut2 = (DataIdentifier) getOutputs()[1];
+
+			// TODO: Add Validation
+			// if (getFirstExpr().getOutput().getDim2() != 1 ||
+			// getFirstExpr().getOutput().getDim2() != 2) {
+			// raiseValidateError("Eigen Decomposition can only be done on a square matrix.
+			// Input matrix is rectangular (rows=" + getFirstExpr().getOutput().getDim1() +
+			// ", cols="+ getFirstExpr().getOutput().getDim2() +")", conditional);
+			// }
+
+			// Output1 - ifft Values
+			ifftOut1.setDataType(DataType.MATRIX);
+			ifftOut1.setValueType(ValueType.FP64);
+			ifftOut1.setDimensions(getFirstExpr().getOutput().getDim1(), getFirstExpr().getOutput().getDim2());
+			ifftOut1.setBlocksize(getFirstExpr().getOutput().getBlocksize());
+
+			// Output2 - ifft Vectors
+			ifftOut2.setDataType(DataType.MATRIX);
+			ifftOut2.setValueType(ValueType.FP64);
+			ifftOut2.setDimensions(getFirstExpr().getOutput().getDim1(), getFirstExpr().getOutput().getDim2());
+			ifftOut2.setBlocksize(getFirstExpr().getOutput().getBlocksize());
+
+			break;
+		}
+		case STFT:
+		{
+			checkMatrixParam(getFirstExpr());
+
+			if ((getFirstExpr() == null || getSecondExpr() == null || getThirdExpr() == null) && _args.length > 0) {
+				raiseValidateError("Missing argument for function " + this.getOpCode(), false,
+						LanguageErrorCodes.INVALID_PARAMETERS);
+			} else if (getFifthExpr() != null) {
+				raiseValidateError("Invalid number of arguments for function " + this.getOpCode().toString().toLowerCase()
+						+ "(). This function only takes 3 or 4 arguments.", false);
+			} else if (_args.length == 3) {
+				checkScalarParam(getSecondExpr());
+				checkScalarParam(getThirdExpr());
+				if (!isPowerOfTwo(((ConstIdentifier) getSecondExpr().getOutput()).getLongValue())) {
+					raiseValidateError("This FFT implementation is only defined for matrices with dimensions that are powers of 2." +
+							"The window size (2nd argument) is not a power of two", false, LanguageErrorCodes.INVALID_PARAMETERS);
+				} else if (((ConstIdentifier) getSecondExpr().getOutput()).getLongValue() <= ((ConstIdentifier) getThirdExpr().getOutput()).getLongValue()) {
+					raiseValidateError("Overlap can't be larger than or equal to the window size.", false, LanguageErrorCodes.INVALID_PARAMETERS);
+				}
+			} else if (_args.length == 4) {
+				checkMatrixParam(getSecondExpr());
+				checkScalarParam(getThirdExpr());
+				checkScalarParam(getFourthExpr());
+				if (!isPowerOfTwo(((ConstIdentifier) getThirdExpr().getOutput()).getLongValue())) {
+					raiseValidateError("This FFT implementation is only defined for matrices with dimensions that are powers of 2." +
+							"The window size (3rd argument) is not a power of two", false, LanguageErrorCodes.INVALID_PARAMETERS);
+				} else if (getFirstExpr().getOutput().getDim1() != getSecondExpr().getOutput().getDim1() || getFirstExpr().getOutput().getDim2() != getSecondExpr().getOutput().getDim2()) {
+					raiseValidateError("The real and imaginary part of the provided matrix are of different dimensions.", false);
+				} else if (((ConstIdentifier) getThirdExpr().getOutput()).getLongValue() <= ((ConstIdentifier) getFourthExpr().getOutput()).getLongValue()) {
+					raiseValidateError("Overlap can't be larger than or equal to the window size.", false, LanguageErrorCodes.INVALID_PARAMETERS);
+				}
+			}
+
+			// setup output properties
+			DataIdentifier stftOut1 = (DataIdentifier) getOutputs()[0];
+			DataIdentifier stftOut2 = (DataIdentifier) getOutputs()[1];
+
+			// Output1 - stft Values
+			stftOut1.setDataType(DataType.MATRIX);
+			stftOut1.setValueType(ValueType.FP64);
+			stftOut1.setDimensions(getFirstExpr().getOutput().getDim1(), getFirstExpr().getOutput().getDim2());
+			stftOut1.setBlocksize(getFirstExpr().getOutput().getBlocksize());
+
+			// Output2 - stft Vectors
+			stftOut2.setDataType(DataType.MATRIX);
+			stftOut2.setValueType(ValueType.FP64);
+			stftOut2.setDimensions(getFirstExpr().getOutput().getDim1(), getFirstExpr().getOutput().getDim2());
+			stftOut2.setBlocksize(getFirstExpr().getOutput().getBlocksize());
+
+			break;
+		}
 		case REMOVE: {
 			checkNumParameters(2);
 			checkListParam(getFirstExpr());
@@ -439,7 +663,11 @@ public void validateExpression(MultiAssignmentStatement stmt, HashMap<String, Da
 			raiseValidateError("Unknown Builtin Function opcode: " + _opcode, false);
 		}
 	}
-
+
+	private static boolean isPowerOfTwo(long n) {
+		return (n > 0) && ((n & (n - 1)) == 0);
+	}
+
 	private static void setDimensions(DataIdentifier out, Expression exp) {
 		out.setDataType(DataType.MATRIX);
 		out.setValueType(ValueType.FP64);

src/main/java/org/apache/sysds/parser/DMLTranslator.java

@@ -2237,6 +2237,11 @@ private Hop processMultipleReturnBuiltinFunctionExpression(BuiltinFunctionExpres
 			case QR:
 			case LU:
 			case EIGEN:
+			case FFT:
+			case IFFT:
+			case FFT_LINEARIZED:
+			case IFFT_LINEARIZED:
+			case STFT:
 			case LSTM:
 			case LSTM_BACKWARD:
 			case BATCH_NORM2D: