diff --git a/Source/CNTK/BrainScript/CNTKCoreLib/CNTK.core.bs b/Source/CNTK/BrainScript/CNTKCoreLib/CNTK.core.bs index 3a5a4f502..656d3bd8e 100644 --- a/Source/CNTK/BrainScript/CNTKCoreLib/CNTK.core.bs +++ b/Source/CNTK/BrainScript/CNTKCoreLib/CNTK.core.bs @@ -26,15 +26,38 @@ IntDiv(x, y) = new NumericFunction [ what = 'IntDiv' ; args = (x:y) ] ############################################################################## -# comparison functions +# aliases ############################################################################## -Less = CNTK2.Less -Equal = CNTK2.Equal -Greater = CNTK2.Greater -GreaterEqual = CNTK2.GreaterEqual -NotEqual = CNTK2.NotEqual -LessEqual = CNTK2.LessEqual +Less = CNTK2.Less +Equal = CNTK2.Equal +Greater = CNTK2.Greater +GreaterEqual = CNTK2.GreaterEqual +NotEqual = CNTK2.NotEqual +LessEqual = CNTK2.LessEqual +Splice = CNTK2.Splice +NewReshape = CNTK2.Reshape +Slice = CNTK2.Slice +TransposeDimensions = CNTK2.TransposeDimensions +Times = CNTK2.Times +Abs = CNTK2.Abs +Ceil = CNTK2.Ceil +CrossEntropyWithSoftmax = CNTK2.CrossEntropyWithSoftmax +Dropout = CNTK2.Dropout +ElementTimes = CNTK2.ElementTimes +ElementDivide = CNTK2.ElementDivide +ErrorPrediction = CNTK2.ErrorPrediction +Exp = CNTK2.Exp +Floor = CNTK2.Floor +Log = CNTK2.Log +Minus = CNTK2.Minus +Pass = CNTK2.Identity +Plus = CNTK2.Plus +RectifiedLinear = CNTK2.Relu +ReduceSum = CNTK2.ReduceSum +ReduceLogSum = CNTK2.ReduceLogSum +Round = CNTK2.Round +Sigmoid = CNTK2.Sigmoid ############################################################################## # ComputationNodes @@ -120,12 +143,11 @@ CNTK2 = [ Square(_, tag='') = ElementTimes(_, _, tag=tag) Tanh(_, tag='') = new ComputationNode [ operation = 'Tanh' ; inputs = _ /*plus the function args*/ ] - // 6. Reductions - ReduceSum (_, axis=0, tag='') = new ComputationNode [ operation = 'ReduceElements' ; inputs = _ ; reductionOp = "Sum" /*plus the function args*/ ] + // 6. Reductions # the following is a temporary workaround until we have the C++ version ReduceLogSum (_, axis=0, tag='') = if axis != 0 then Fail("ReduceLogSum for now only supports axis=0.") else [ tag1=tag ; axis1=axis ; out = RowSlice (0, 1, _ - LogSoftmax (_), tag=tag1) ].out - + ReduceSum (_, axis=0, tag='') = new ComputationNode [ operation = 'ReduceElements' ; inputs = _ ; reductionOp = "Sum" /*plus the function args*/ ] // 7. Control flow (if, composite etc.) // None so far @@ -150,7 +172,7 @@ CNTK2 = [ CrossEntropyWithSoftmax(_, outProbVectorSequence, tag='') = new ComputationNode [ operation = 'CrossEntropyWithSoftmax' ; inputs = (_ : outProbVectorSequence) /*plus the function args*/ ] ErrorPrediction(_, outVectorSequence, topN=1, tag='') = new ComputationNode [ operation = 'ErrorPrediction' ; inputs = if topN == 1 then (_ : outVectorSequence) else (_ : outVectorSequence : Constant (topN)) /*plus the function args*/ ] - // 13. Comparison nodes + // 12. Comparison nodes Less(_, y, tag='') = new ComputationNode [ operation = 'Less' ; inputs = (_ : y) /*plus the function args*/ ] Equal(_, y, tag='') = new ComputationNode [ operation = 'Equal' ; inputs = (_ : y) /*plus the function args*/ ] Greater(_, y, tag='') = new ComputationNode [ operation = 'Greater' ; inputs = (_ : y) /*plus the function args*/ ] @@ -158,8 +180,7 @@ CNTK2 = [ NotEqual(_, y, tag='') = new ComputationNode [ operation = 'NotEqual' ; inputs = (_ : y) /*plus the function args*/ ] LessEqual(_, y, tag='') = new ComputationNode [ operation = 'LessEqual' ; inputs = (_ : y) /*plus the function args*/ ] - // 13. Others - // 12. Others + // 13. Others Identity(_, tag='') = new ComputationNode [ operation = 'Pass' ; inputs = _ /*plus the function args*/ ] ] @@ -184,36 +205,12 @@ Shift(input, fromOffset, boundaryValue, boundaryMode=-1/*context*/, dim=-1, tag= RowSlice(beginIndex, numRows, input, tag='') = Slice(beginIndex, beginIndex + numRows, input, axis = 1) RowRepeat(input, numRepeats, tag='') = new ComputationNode [ operation = 'RowRepeat' ; inputs = input /*plus the function args*/ ] RowStack(inputs, tag='') = new ComputationNode [ operation = 'RowStack' /*plus the function args*/ ] -Splice (inputs, axis=1, tag='') = # TODO: This is a workaround. RowStack itself shall interpret 'axis' and be renamed to Splice(). - if axis < 1 then Fail('Splice does not yet implement splicing the time axis.') - else if axis == 1 then [tag1=tag; out = RowStack (inputs, tag=tag1)].out - else [ # workaround: swap 'axis' to first position, RowStack, swap back - ArrayTransposeDimensions (inputs, axis1, axis2) = [ # transpose each element of a BS array - inputsT[i:0..Length(inputs)-1] = TransposeDimensions (inputs[i], axis1, axis2) - ].inputsT - out = [tag1=tag; out=TransposeDimensions (RowStack (ArrayTransposeDimensions (inputs, 1, axis)), 1, axis, tag=tag)].out - ].out Reshape(input, numRows, imageWidth = 0, imageHeight = 0, imageChannels = 0, tag='') = new ComputationNode [ operation = 'LegacyReshape' ; inputs = input /*plus the function args*/ ] -NewReshape(input, dims, beginAxis=0, endAxis=0, tag='') = new ComputationNode [ operation = 'Reshape' ; inputs = input ; shape = new TensorShape [ /*dims*/ ] /*plus the function args*/ ] ReshapeDimension(x, axis, tensorShape) = NewReshape(x, tensorShape, beginAxis=axis, endAxis=axis + 1) FlattenDimensions(x, axis, num) = NewReshape(x, 0, beginAxis=axis, endAxis=axis + num) -Slice(beginIndex, endIndex, input, axis=1, tag='') = - if axis < 0 then [ # time axis: specify -1 - beginFlags = if beginIndex > 0 then BS.Boolean.Not (BS.Loop.IsFirstN (beginIndex, input)) else BS.Loop.IsLastN (-beginIndex, input) - endFlags = if endIndex > 0 then BS.Loop.IsFirstN (endIndex, input) else BS.Boolean.Not (BS.Loop.IsLastN (-endIndex, input)) - flags = if beginIndex == 0 then endFlags - else if endIndex == 0 then beginFlags - else BS.Boolean.And (beginFlags, endFlags) - out = if beginIndex == 0 && endIndex == 0 - then input - else BS.Sequences.Gather (flags, input) - ].out - else new ComputationNode [ operation = 'Slice' ; inputs = input /*plus the function args*/ ] # non-time axis SplitDimension(x, axis, N) = ReshapeDimension(x, axis, 0:N) -TransposeDimensions(input, axis1, axis2, tag='') = new ComputationNode [ operation = 'TransposeDimensions' ; inputs = input /*plus the function args*/ ] # TODO: make input the last arg! Transpose(x) = TransposeDimensions(x, 1, 2) -Times(A, B, outputRank=1, tag='') = new ComputationNode [ operation = 'Times' ; inputs = ( A : B ) /*plus the function args*/ ] Logistic(label, probability, tag='') = new ComputationNode [ operation = 'Logistic' ; inputs = (label : probability) /*plus the function args*/ ] WeightedLogistic(label, probability, instanceWeight, tag='') = new ComputationNode [ operation = 'Logistic' ; inputs = (label : probability : instanceWeight) /*plus the function args*/ ] ReconcileDynamicAxis(dataInput, layoutInput, tag='') = new ComputationNode [ operation = 'ReconcileDynamicAxis' ; inputs = (dataInput : layoutInput) /*plus the function args*/ ] @@ -231,8 +228,6 @@ ClassificationError = ErrorPrediction Delay = PastValue BatchNormalization(input, scale, bias, runMean, runInvStdDev, spatial, normalizationTimeConstant = 0, blendTimeConstant = 0, epsilon = 0.00001, useCntkEngine = true, imageLayout='CHW', tag='') = new ComputationNode [ operation = 'BatchNormalization' ; inputs = (input : scale : bias : runMean : runInvStdDev) /*plus the function args*/ ] -Abs(x, tag='') = new ComputationNode [ operation = 'Abs' ; inputs = x /*plus the function args*/ ] -Ceil(x, tag='') = Negate(Floor(Negate(x)), tag=tag) ClassBasedCrossEntropyWithSoftmax(labelClassDescriptorVectorSequence, mainInputInfo, mainWeight, classLogProbsBeforeSoftmax, tag='') = new ComputationNode [ operation = 'ClassBasedCrossEntropyWithSoftmax' ; inputs = (labelClassDescriptorVectorSequence : mainInputInfo : mainWeight : classLogProbsBeforeSoftmax) /*plus the function args*/ ] Clip(minValue, maxValue, x, tag='') = new ComputationNode [ operation = 'Clip' ; inputs = (minValue : maxValue : x) /* plus the function args*/ ] ColumnElementTimes(aVectorSequence, anotherVectorSequence, tag='') = new ComputationNode [ operation = 'ColumnElementTimes' ; inputs = (aVectorSequence : anotherVectorSequence) /*plus the function args*/ ] @@ -241,50 +236,33 @@ CosDistance(aVectorSequence, anotherVectorSequence, tag='') = new ComputationNod CosDistanceWithNegativeSamples(aVectorSequence, anotherVectorSequence, numShifts, numNegSamples, tag='') = new ComputationNode [ operation = 'CosDistanceWithNegativeSamples' ; inputs = (aVectorSequence : anotherVectorSequence : numShifts : numNegSamples) /*plus the function args*/ ] Cosine(x, tag='') = new ComputationNode [ operation = 'Cosine' ; inputs = x /*plus the function args*/ ] CrossEntropy(refProbVectorSequence, outProbVectorSequence, tag='') = new ComputationNode [ operation = 'CrossEntropy' ; inputs = (refProbVectorSequence : outProbVectorSequence) /*plus the function args*/ ] -CrossEntropyWithSoftmax(labelVectorSequence, outProbVectorSequence, tag='') = new ComputationNode [ operation = 'CrossEntropyWithSoftmax' ; inputs = (labelVectorSequence : outProbVectorSequence) /*plus the function args*/ ] # once ReduceLogSum becomes proper C++, CrossEntropyWithSoftmax() will become this: NewCrossEntropyWithSoftmax (labelSequence, z, tag='') = [ tag1 = tag; out = Minus (ReduceLogSum (z), ReduceSum (labelSequence .* z), tag=tag1) ].out DiagTimes(diagonalMatrixAsColumnVector, matrix, tag='') = new ComputationNode [ operation = 'DiagTimes' ; inputs = (diagonalMatrixAsColumnVector : matrix) /*plus the function args*/ ] // TODO: DiagTimes = ElementTimes -Dropout(activationVectorSequence, tag='') = new ComputationNode [ operation = 'Dropout' ; inputs = activationVectorSequence /*plus the function args*/ ] -ElementTimes(aMatrix, anotherMatrix, tag='') = new ComputationNode [ operation = 'ElementTimes' ; inputs = (aMatrix : anotherMatrix) /*plus the function args*/ ] -ElementDivide(aMatrix, anotherMatrix, tag='') = ElementTimes(aMatrix, Reciprocal(anotherMatrix), tag=tag) -ErrorPrediction = CNTK2.ErrorPrediction -Exp(x, tag='') = new ComputationNode [ operation = 'Exp' ; inputs = x /*plus the function args*/ ] -Floor(x, tag='') = new ComputationNode [ operation = 'Floor' ; inputs = x /*plus the function args*/ ] GatherPacked(indexSequence, sourceData, tag='') = new ComputationNode [ operation = 'GatherPacked' ; inputs = (indexSequence : sourceData) /*plus the function args*/ ] GMMLogLikelihood(unnormalizedPriorVector, meansAsRows, logStdDevAsRows, dataVectorSequence, tag='') = new ComputationNode [ operation = 'GMMLogLikelihood' ; inputs = (unnormalizedPriorVector : meansAsRows : logStdDevAsRows : dataVectorSequence) /*plus the function args*/ ] InvStdDev(dataVectorSequence, tag='') = new ComputationNode [ operation = 'InvStdDev' ; inputs = dataVectorSequence /*plus the function args*/ ] KhatriRaoProduct(leftMatrix, rightMatrix, tag='') = new ComputationNode [ operation = 'KhatriRaoProduct' ; inputs = (leftMatrix : rightMatrix) /*plus the function args*/ ] -Log(x, tag='') = new ComputationNode [ operation = 'Log' ; inputs = x /*plus the function args*/ ] LogPlus(leftMatrix, rightMatrix, tag='') = new ComputationNode [ operation = 'LogPlus' ; inputs = (leftMatrix : rightMatrix) /*plus the function args*/ ] LogSoftmax(z, tag='') = new ComputationNode [ operation = 'LogSoftmax' ; inputs = z /*plus the function args*/ ] # TODO: ^^ along axis, like Softmax MatrixL1Reg(matrix, tag='') = new ComputationNode [ operation = 'MatrixL1Reg' ; inputs = matrix /*plus the function args*/ ] MatrixL2Reg(matrix, tag='') = new ComputationNode [ operation = 'MatrixL2Reg' ; inputs = matrix /*plus the function args*/ ] Mean(dataVectorSequence, tag='') = new ComputationNode [ operation = 'Mean' ; inputs = dataVectorSequence /*plus the function args*/ ] -Minus(leftMatrix, rightMatrix, tag='') = new ComputationNode [ operation = 'Minus' ; inputs = (leftMatrix : rightMatrix) /*plus the function args*/ ] Negate(input, tag='') = new ComputationNode [ operation = 'Negate' ; inputs = input /*plus the function args*/ ] PackedIndex(targetObject, indexSequence, tag='') = new ComputationNode [ operation = 'PackedIndex' ; inputs = (targetObject : indexSequence) /*plus the function args*/ ] -Pass(x, tag='') = new ComputationNode [ operation = 'Pass' ; inputs = x /*plus the function args*/ ] PerDimMeanVarDeNormalization(dataVectorSequence, meanVector, invStdDevVector, tag='') = new ComputationNode [ operation = 'PerDimMeanVarDeNormalization' ; inputs = (dataVectorSequence : meanVector : invStdDevVector) /*plus the function args*/ ] PerDimMeanVarNormalization(dataVectorSequence, meanVector, invStdDevVector, tag='') = new ComputationNode [ operation = 'PerDimMeanVarNormalization' ; inputs = (dataVectorSequence : meanVector : invStdDevVector) /*plus the function args*/ ] -Plus(leftMatrix, rightMatrix, tag='') = new ComputationNode [ operation = 'Plus' ; inputs = (leftMatrix : rightMatrix) /*plus the function args*/ ] Reciprocal(z, tag='') = new ComputationNode [ operation = 'Reciprocal' ; inputs = z /*plus the function args*/ ] -RectifiedLinear(z, tag='') = new ComputationNode [ operation = 'RectifiedLinear' ; inputs = z /*plus the function args*/ ] -ReduceSum (z, axis=0, tag='') = new ComputationNode [ operation = 'ReduceElements' ; inputs = z ; reductionOp = "Sum" /*plus the function args*/ ] -# the following is a temporary workaround until we have the C++ version -ReduceLogSum (z, axis=0, tag='') = if axis != 0 then Fail("ReduceLogSum for now only supports axis=0.") - else [ tag1=tag ; axis1=axis ; out = RowSlice (0, 1, z - LogSoftmax (z), tag=tag1) ].out +//# the following is a temporary workaround until we have the C++ version #ReduceLogSum (z, axis=0, tag='') = new ComputationNode [ operation = 'ReduceElements' ; inputs = z ; reductionOp = "LogSum" /*plus the function args*/ ] #ReduceMean (z, axis=0, tag='') = new ComputationNode [ operation = 'ReduceElements' ; inputs = z ; reductionOp = "Mean" /*plus the function args*/ ] #ReduceMax (z, axis=0, tag='') = new ComputationNode [ operation = 'ReduceElements' ; inputs = z ; reductionOp = "Max" /*plus the function args*/ ] #ReduceMin (z, axis=0, tag='') = new ComputationNode [ operation = 'ReduceElements' ; inputs = z ; reductionOp = "Min" /*plus the function args*/ ] -Round(x, tag='') = Floor(Plus(x, ConstantTensor(0.5, (1))), tag=tag) Scale(scalarScalingFactor, matrix, tag='') = new ComputationNode [ operation = 'Scale' ; inputs = (scalarScalingFactor : matrix) /*plus the function args*/ ] # TODO: Scale = ElementTimes ScatterPacked(cond, indexSequence, sourceData, tag='') = new ComputationNode [ operation = 'ScatterPacked' ; inputs = (cond : indexSequence : sourceData) /*plus the function args*/ ] -Sigmoid(z, tag='') = new ComputationNode [ operation = 'Sigmoid' ; inputs = z /*plus the function args*/ ] Sin(z, tag='') = new ComputationNode [ operation = 'Sin' ; inputs = z /*plus the function args*/ ] Softmax (z, axis=0, tag='') = # TODO: replace this with more efficient version below once we have ReduceLogSum if axis == 0 then new ComputationNode [ operation = 'Softmax' ; inputs = z /*plus the function args*/ ] diff --git a/contrib/Python/cntk/ops/__init__.py b/contrib/Python/cntk/ops/__init__.py index cf59429de..5491b9db2 100644 --- a/contrib/Python/cntk/ops/__init__.py +++ b/contrib/Python/cntk/ops/__init__.py @@ -416,6 +416,7 @@ def identity(x, name=None): Args: x: numpy array or any :class:`cntk.graph.ComputationNode` that outputs a tensor + name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` """ @@ -547,8 +548,8 @@ def clip(x, min_value, max_value, name=None): Args: x: tensor to be clipped - min_value: the minimum value to clip element values to - max_value: the maximum value to clip element values to + min_value: a scalar or a tensor which represents the minimum value to clip element values to + max_value: a scalar or a tensor which represents the maximum value to clip element values to name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` @@ -572,6 +573,7 @@ def relu(x, name=None): Args: x: numpy array or any :class:`cntk.graph.ComputationNode` that outputs a tensor + name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` """ @@ -595,6 +597,7 @@ def sigmoid(x, name=None): Args: x: numpy array or any :class:`cntk.graph.ComputationNode` that outputs a tensor + name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` """ @@ -617,6 +620,7 @@ def tanh(x, name=None): Args: x: numpy array or any :class:`cntk.graph.ComputationNode` that outputs a tensor + name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` """ @@ -644,6 +648,7 @@ def softmax(x, name=None): Args: x: numpy array or any :class:`cntk.graph.ComputationNode` that outputs a tensor + name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` """ @@ -665,6 +670,7 @@ def exp(x, name=None): Args: x: numpy array or any :class:`cntk.graph.ComputationNode` that outputs a tensor + name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` """ @@ -684,6 +690,7 @@ def log(x, name=None): Args: x: numpy array or any :class:`cntk.graph.ComputationNode` that outputs a tensor + name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` @@ -711,6 +718,7 @@ def sqrt(x, name=None): Args: x: numpy array or any :class:`cntk.graph.ComputationNode` that outputs a tensor + name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` @@ -734,6 +742,7 @@ def square(x, name=None): Args: x: numpy array or any :class:`cntk.graph.ComputationNode` that outputs a tensor + name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` """ @@ -755,6 +764,7 @@ def abs(x, name=None): Args: x: numpy array or any :class:`cntk.graph.ComputationNode` that outputs a tensor + name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` """ @@ -815,8 +825,9 @@ def future_value(shape, x, time_step=1, default_hidden_activation=0.1, name=None Args: shape (tuple): dimensions of the input `x`, the shape will be inferred if zero is passed. x: the tensor (or its name) from which the future value is obtained. - time_step: the number of time steps to look into the future (default 1) - default_hidden_activation: the default value to use when no future value is available (default 0.1) + time_step (int): the number of time steps to look into the future (default 1) + default_hidden_activation (number): the default value to use when no future value is available (default 0.1) + name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` """ @@ -849,8 +860,9 @@ def past_value(shape, x, time_step=1, default_hidden_activation=0.1, name=None): Args: shape (tuple): dimensions of the input `x`, the shape will be inferred if zero is passed. x: the tensor (or its name) from which the past value is obtained - time_step: the number of time steps to look into the past (default 1) - default_hidden_activation: the default value to use when no past value is available (default 0.1) + time_step (int): the number of time steps to look into the past (default 1) + default_hidden_activation (number): the default value to use when no past value is available (default 0.1) + name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` """ @@ -910,6 +922,7 @@ def transpose_dimensions(x, axis1, axis2, name=None): x: tensor to be reshaped axis1 (int): the axis to swap with axis2 axis2 (int): the axis to swap with axis1 + name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` """ @@ -954,7 +967,8 @@ def slice(x, begin_index, end_index, axis=0, name=None): begin_index (int): the index along axis where the slicing starts end_index (int): the index along axis where the slicing ends axis (int or str): axis along which `begin_index` and `end_index` will be used. If axis is of type `str` then the time axis will be used. - + name (str): the name of the node in the network + See also: Indexing in NumPy: http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html @@ -1000,6 +1014,7 @@ def splice(inputs, axis=0, name=None): Args: inputs (list): tuple of input tensors axis (int): axis along which the concatenation will be performed + name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` @@ -1049,6 +1064,7 @@ def reduce_sum(x, axis=0, name=None): Args: x: input tensor axis (int): axis along which the reduction will be performed + name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` @@ -1077,6 +1093,7 @@ def reduce_log_sum(inputs, name=None): Args: x: input tensor + name (str): the name of the node in the network Returns: :class:`cntk.graph.ComputationNode` @@ -1108,6 +1125,8 @@ def dropout(x, name=None): Args: x: source tensor + name (str): the name of the node in the network + Returns: :class:`cntk.graph.ComputationNode` """ @@ -1135,6 +1154,8 @@ def input_numpy(value, alias=None, dynamic_axis='', name=None): alias (str): alias to be used in the data file dynamic_axis (str): whether the tensor has already the data alias (str): optional the alias to be used when serializing the data into an intermediate file + name (str): the name of the node in the network + Returns: :class:`cntk.graph.ComputationNode` ''' @@ -1172,6 +1193,7 @@ def input(shape, dynamic_axis='', name=None): shape (tuple): the shape of the input tensor dynamic_axis (str or output of :func:`cntk.ops.dynamic_axis`): the dynamic axis name (str): the name of the node in the network + Returns: :class:`cntk.graph.ComputationNode` """ @@ -1222,6 +1244,8 @@ def sparse_input_numpy(indices, values, shape, alias=None, dynamic_axis='', name alias (str): alias to be used in the data file dynamic_axis (str): whether the tensor has already the data alias (str): optional the alias to be used when serializing the data into an intermediate file + name (str): the name of the node in the network + Returns: :class:`cntk.graph.ComputationNode` ''' diff --git a/contrib/Python/cntk/ops/tests/reduction_test.py b/contrib/Python/cntk/ops/tests/reduction_test.py index c7bfc98cf..fa0569f20 100644 --- a/contrib/Python/cntk/ops/tests/reduction_test.py +++ b/contrib/Python/cntk/ops/tests/reduction_test.py @@ -30,13 +30,13 @@ def test_op_reduce_sum(input_data, axis, device_id, precision): # The first for sequences (length=1, since we have dynamic_axis=''). # The second for batch of one sample. - # keepdims = True as CNTK keep them as well + # keepdims = True as CNTK keeps them as well def reduce_sum(x, axis, keepdims=True): x_aa = AA(x) if axis == len(x_aa.shape): - return [AA(np.reshape(np.add.reduce(np.ravel(x_aa)), (1,1)))] - return [[AA(np.add.reduce(x, axis, dtype=PRECISION_TO_TYPE[precision], - keepdims=keepdims))]] + return [np.reshape(np.add.reduce(np.ravel(x_aa)), (1,1))] + return [[np.add.reduce(x_aa, axis, dtype=PRECISION_TO_TYPE[precision], + keepdims=keepdims)]] expected_result = reduce_sum(input_data, axis)