def op(self, data, center): """The definition of the operator function. Thread pool over nData. This may generate too many threads for some input data. :param data: 2D matrix as data input with dimensions: nDim x nData. :type data; numpy array. :param center: 2D matrix of initial cluster centers with dimensions: nDim x nCenter. :type center: numpy array. :return minIndex: 1D matrix of assignemnts of data points to cluster centers: nData x 1. """ nDimData = data.shape[0] nDimCenter = center.shape[0] nData = data.shape[1] nCenter = center.shape[1] assert nDimData == nDimCenter, "Data has % dimensions and centers have %d dimensions, but these must match!" % (nDimData, nDimCenter) nDim = nDimData iSample = ops.position_in(nData)[0] minDist = ops.variable(sys.float_info.max, data.dtype) iMin = ops.variable(0, ops.int64) for iCenter in ops.arange(nCenter): dist = ops.variable(0, center.dtype) for iDim in ops.arange(nDim): dist <<= dist + (data[iDim,iSample]-center[iDim,iCenter])*(data[iDim,iSample]-center[iDim,iCenter]) with ops.if_(dist < minDist): iMin <<= iCenter minDist <<= dist #TODO([email protected]): Change this to uint64 whenever ovl supports non-floating point types for tensors. minIndex = ops.output(nData, ops.float64) # Use float64 because tensorflow does not support uint64 as type yet. minIndex[iSample] = ops.cast(iMin, ops.float64) return minIndex
def op(self, data, minIndex, nCenter): """The definition of the operator function. Thread pool over nCenter. That should be fine for most cases. :param data: 2D matrix as data input with dimensions: nDim x nData. :type data: numpy array. :param minIndex: 1D matrix of assignemnts of data points to cluster centers: nData x 1. :type minIndex: numpy array. :return 2D matrix with computed cluster centers with dimensions> nDim x nCenter. """ nDim = data.shape[0] nData = data.shape[1] assert nData==minIndex.shape[0], "Data has %d values and minDist has %d values, but these must match!" % (nData, minIndex.shape[0]) iCenter = ops.position_in(nCenter)[0] center = ops.zeros([nDim,nCenter], data.dtype) count = ops.variable(0, data.dtype) for iSample in ops.arange(nData): with ops.if_(iCenter==ops.cast(minIndex[iSample], ops.uint32)): count <<= count + 1 for iDim in ops.arange(nDim): center[iDim,iCenter] = center[iDim,iCenter] + data[iDim,iSample] newCenter = ops.output([nDim,nCenter],data.dtype) for iDim in ops.arange(nDim): newCenter[iDim,iCenter] = center[iDim,iCenter]/count return newCenter
def lstm(concat, c, forget_bias=None): batches = concat.shape[0] vec_len = concat.shape[1]/4 assert c.shape[0] == concat.shape[0] assert c.shape[1] == vec_len assert c.dtype == concat.dtype pos = ovl.position_in([batches, vec_len]) cur_batch = pos[0] cur_elem = pos[1] i = concat[cur_batch, cur_elem] j = concat[cur_batch, cur_elem + vec_len] f = concat[cur_batch, cur_elem + 2*vec_len] o = concat[cur_batch, cur_elem + 3*vec_len] c_cur = c[cur_batch, cur_elem] new_c = ovl.output_like(c) new_h = ovl.output_like(c) new_c_cur = c_cur*sig(f + forget_bias) + sig(i) * ovl.tanh(j) new_c[pos] = new_c_cur new_h[pos] = ovl.tanh(new_c_cur) * sig(o) return new_c, new_h
def op(self, startEdge, fromVertex, toVertex): """The definition of the operator function. The array toVertex is a flattened list of lists structure, where startEdge encodes the start indices of the separate lists. :param startEdge: Indices into toVertex where edges start. :type startEdge: list. :param fromVertex: The from-vertex of each edge. :type fromVertex: list. :param toVertex: The to-vertex of each edge. :type toVertex: list. :return Counts of triangles per edge. """ iEdge = ops.position_in(toVertex.shape)[0] count = ops.output(toVertex.shape, ops.uint64) nTriangle = ops.variable(0, ops.uint64) iFromVertex = ops.variable(fromVertex[iEdge], fromVertex.dtype) iFromEdge = ops.variable(startEdge[iFromVertex], startEdge.dtype) iFromEdgeEnd = ops.variable(startEdge[iFromVertex+1], startEdge.dtype) iiFromVertex = ops.variable(toVertex[iFromEdge], toVertex.dtype) iToVertex = ops.variable(toVertex[iEdge], toVertex.dtype) iToEdge = ops.variable(startEdge[iToVertex], startEdge.dtype) iToEdgeEnd = ops.variable(startEdge[iToVertex+1], startEdge.dtype) iiToVertex = ops.variable(toVertex[iToEdge], toVertex.dtype) nMerge = iToEdgeEnd-iToEdge + iFromEdgeEnd-iFromEdge # Maximum number of merges. # This construction is a work-around for simulating the function of a while loop. #TODO([email protected]): Replace this construct by a while loop once it is available in ovl. for iMerge in ops.arange(nMerge): doMerge = ops.logical_and(iFromEdge < iFromEdgeEnd, iToEdge < iToEdgeEnd) doMerge = ops.logical_and(doMerge, iiFromVertex < iToVertex) with ops.if_(doMerge): with ops.if_(iiFromVertex < iiToVertex): iFromEdge <<= iFromEdge+1 iiFromVertex <<= toVertex[iFromEdge] with ops.elif_(iiFromVertex > iiToVertex): iToEdge <<= iToEdge+1 iiToVertex <<= toVertex[iToEdge] with ops.else_(): nTriangle <<= nTriangle+1 iFromEdge <<= iFromEdge+1 iToEdge <<= iToEdge+1 iiFromVertex <<= toVertex[iFromEdge] iiToVertex <<= toVertex[iToEdge] #TODO([email protected]): Use a reduction function that computes a partial or complete sum. count[iEdge] = nTriangle # Save the triangles for each edge. return count
def op(self, input0, input1, input2): pos = ops.position_in(input0.shape) out0 = ops.output_like(input0) a = input0[pos] b = input1[pos] c = input2[pos] d = a*a + b*b + c*c out0[pos] = d return out0
def accumulate(x, inner_fcn=None, axis=None): """ Define the operator function. :param x: The input tensor :param inner_fcn: a lambda function to be applied for accumulation :param axis: The axis across which accumulation will be applied :return: The accumulated result """ # assert that the axis parameter makes sense assert isinstance(axis, int) assert axis >= 0 assert axis < x.rank # Define the workgroup shape. Here we use a single worker to perform the accumulation across the # accumulation axis. The workgroup shape is then the size of all other axes with accumulation axis removed. if x.rank is 1: workgroup_shape = [1] else: workgroup_shape = [] for cur_dim, num_elements in enumerate(x.shape): if cur_dim == axis: pass else: workgroup_shape.append(num_elements) pos = ovl.position_in(workgroup_shape) # Define the accumulated output to be the same type as the input out = ovl.output_like(x) # Define a function for determining the index of the input tensor as a function of accumulation axis position # and the current worker position. This is equal to the worker position with the accumulation axis position # inserted where it should be in the indexing order. def resolve_position(axis_n): cur_pos = [] offset = 0 for cur_dim in range(x.rank): if cur_dim == axis: cur_pos.append(axis_n) offset = 1 else: cur_pos.append(pos[cur_dim - offset]) return cur_pos # initialize accumulator to be the first element along the accumulation axis initial_value = x[resolve_position(0)] accum = ovl.variable(initial_value, x.dtype) out[resolve_position(0)] = accum # use this worker to iterate over and accumulate the rest of the elements in the accumulation axis for i in ovl.arange(1, x.shape[axis]): accum <<= inner_fcn(accum, x[resolve_position(i)]) out[resolve_position(i)] = accum return out
def accumulate(x, inner_fcn=None, axis=None): """ Define the operator function. :param x: The input tensor :param inner_fcn: a lambda function to be applied for accumulation :param axis: The axis across which accumulation will be applied :return: The accumulated result """ # assert that the axis parameter makes sense assert isinstance(axis, int) assert axis >= 0 assert axis < x.rank # Define the workgroup shape. Here we use a single worker to perform the accumulation across the # accumulation axis. The workgroup shape is then the size of all other axes with accumulation axis removed. if x.rank is 1: workgroup_shape = [1] else: workgroup_shape = [] for cur_dim, num_elements in enumerate(x.shape): if cur_dim == axis: pass else: workgroup_shape.append(num_elements) pos = ovl.position_in(workgroup_shape) # Define the accumulated output to be the same type as the input out = ovl.output_like(x) # Define a function for determining the index of the input tensor as a function of accumulation axis position # and the current worker position. This is equal to the worker position with the accumulation axis position # inserted where it should be in the indexing order. def resolve_position(axis_n): cur_pos = [] offset = 0 for cur_dim in range(x.rank): if cur_dim == axis: cur_pos.append(axis_n) offset = 1 else: cur_pos.append(pos[cur_dim-offset]) return cur_pos # initialize accumulator to be the first element along the accumulation axis initial_value = x[resolve_position(0)] accum = ovl.variable(initial_value, x.dtype) out[resolve_position(0)] = accum # use this worker to iterate over and accumulate the rest of the elements in the accumulation axis for i in ovl.arange(1, x.shape[axis]): accum <<= inner_fcn(accum, x[resolve_position(i)]) out[resolve_position(i)] = accum return out
def op(self, input0, input1, input2): sum = ops.output_like(input0) pos = ops.position_in(input0.shape) a = input0[pos] b = input1[pos] c = input2[pos] sum[pos] = ops.sqrt(a*a + b*b + c*c) return sum
def log1p_grad(x, grad): """ Define the log1p gradient operator by defining the its operator function to be .. math:: out_{i} = 1.0 / (x_{i} + 1.0) * grad_{i} :param x: The input tensor argument :param grad: The input gradient tensor to the gradient operator :return: Element-wise gradient of the original operator """ out = ovl.output(x.shape, x.dtype) pos = ovl.position_in(x.shape) out[pos] = 1.0 / (x[pos] + 1.0) * grad[pos] return out
def lstm_grad(concat, c, d_new_c, d_new_h, forget_bias=None): batches = concat.shape[0] vec_len = concat.shape[1]/4 assert c.shape[0] == concat.shape[0] assert c.shape[1] == vec_len assert c.dtype == concat.dtype assert d_new_c.tensor_type == c.tensor_type assert d_new_h.tensor_type == c.tensor_type pos = ovl.position_in([batches, vec_len]) cur_batch = pos[0] cur_elem = pos[1] i = concat[cur_batch, cur_elem] j = concat[cur_batch, cur_elem + vec_len] f = concat[cur_batch, cur_elem + 2*vec_len] o = concat[cur_batch, cur_elem + 3*vec_len] c_cur = c[cur_batch, cur_elem] new_c_cur = c_cur*sig(f + forget_bias) + sig(i) * ovl.tanh(j) d_new_c_cur = d_new_c[cur_batch, cur_elem] d_new_h_cur = d_new_h[cur_batch, cur_elem] d_concat = ovl.output_like(concat) d_c = ovl.output_like(c) back_ch = d_new_c_cur + tanh_grad(new_c_cur)*sig(o)*d_new_h_cur d_i = ovl.tanh(j)*sig_grad(i)*back_ch d_j = sig(i)*tanh_grad(j)*back_ch d_f = c_cur*sig_grad(f+forget_bias)*back_ch d_c_cur = sig(f+forget_bias)*back_ch d_o = ovl.tanh(new_c_cur)*sig_grad(o)*d_new_h_cur d_concat[cur_batch, cur_elem] = d_i d_concat[cur_batch, cur_elem+vec_len] = d_j d_concat[cur_batch, cur_elem+2*vec_len] = d_f d_concat[cur_batch, cur_elem+3*vec_len] = d_o d_c[pos] = d_c_cur return d_concat, d_c
def expm1(x): """ Define the expm1 operator by defining the its operator function to be .. math:: out_{i} = exp(x_{i}) - 1.0 :param x: The input tensor :return: Element-wise exp(x) - 1 :Examples: .. doctest:: >>> import numpy as np >>> from opveclib import evaluate >>> from opveclib.examples import expm1 >>> a = np.array([1e-10, -1e-10]) >>> evaluate(expm1(a)) array([ 1.00000000e-10, -1.00000000e-10]) >>> np.expm1(a) array([ 1.00000000e-10, -1.00000000e-10]) >>> ones = np.ones_like(a) >>> np.exp(a) - ones array([ 1.00000008e-10, -1.00000008e-10]) """ output = ovl.output_like(x) pos = ovl.position_in(x.shape) e = ovl.exp(x[pos]) # note, this is an example of the use of the OVL conditional operators with ovl.if_(ovl.logical_and(ovl.isinf(x[pos]), x[pos] > 0.0)): output[pos] = x[pos] with ovl.elif_(e == 1.0): output[pos] = x[pos] with ovl.elif_((e - 1.0) == -1.0): output[pos] = -1.0 with ovl.else_(): output[pos] = (e - 1.0) * x[pos] / ovl.log(e) return output
def expm1(x): """ Define the expm1 operator by defining the its operator function to be .. math:: out_{i} = exp(x_{i}) - 1.0 :param x: The input tensor :return: Element-wise exp(x) - 1 :Examples: .. doctest:: >>> import numpy as np >>> from opveclib import evaluate >>> from opveclib.examples import expm1 >>> a = np.array([1e-10, -1e-10]) >>> evaluate(expm1(a)) array([ 1.00000000e-10, -1.00000000e-10]) >>> np.expm1(a) array([ 1.00000000e-10, -1.00000000e-10]) >>> ones = np.ones_like(a) >>> np.exp(a) - ones array([ 1.00000008e-10, -1.00000008e-10]) """ output = ovl.output_like(x) pos = ovl.position_in(x.shape) e = ovl.exp(x[pos]) # note, this is an example of the use of the OVL conditional operators with ovl.if_(ovl.logical_and(ovl.isinf(x[pos]), x[pos] > 0.0)): output[pos] = x[pos] with ovl.elif_(e == 1.0): output[pos] = x[pos] with ovl.elif_ ((e - 1.0) == -1.0): output[pos] = -1.0 with ovl.else_(): output[pos] = (e - 1.0) * x[pos] / ovl.log(e) return output
def log1p(x): """ Define the log1p operator by defining the its operator function to be .. math:: out_{i} = log(1.0 + x_{i}) :param x: The input tensor :return: Element-wise log(1 + x) :Examples: .. doctest:: >>> import numpy as np >>> from opveclib import evaluate >>> from opveclib.examples import log1p >>> a = np.array([1e-99, -1e-99]) >>> evaluate(log1p(a)) array([ 1.00000000e-99, -1.00000000e-99]) >>> np.log1p(a) array([ 1.00000000e-99, -1.00000000e-99]) >>> ones = np.ones_like(a) >>> np.log(ones + a) array([ 0., 0.]) """ output = ovl.output_like(x) pos = ovl.position_in(x.shape) u = 1.0 + x[pos] d = u - 1.0 # note, this is an example of the use of the OVL conditional operators with ovl.if_(ovl.logical_and(ovl.isinf(x[pos]), x[pos] > 0.0)): output[pos] = x[pos] with ovl.elif_(d == 0): output[pos] = x[pos] with ovl.else_(): output[pos] = ovl.log(u) * x[pos] / d return output
def triangles_op(startEdge, fromVertex, toVertex): """Counts the triangles in an undirected graph. Notice that this method assumes that the graph is given as an adjacency list where all lists with vertex neighbors are sorted. The parallel algorithm uses the following strategy. We map one thread per edge, This is also called the edge-based iterator strategy. The idea behind the algorithm is: 1. Go over all edges (u, v). 2. The neighboring indices for vertex u are N(u) and for vertex v are N(v). 3. Increment the triangle counter by | N(u) /\ N(v) | where /\ is the set intersection operator. We enforce an order on the vertices that avoids counting the same triangle three times, instead each triangle is counted once. Attributes: None. The array toVertex is a flattened list of lists structure, where startEdge encodes the start indices of the separate lists. :param startEdge: Indices into toVertex where edges start. :type startEdge: list. :param fromVertex: The from-vertex of each edge. :type fromVertex: list. :param toVertex: The to-vertex of each edge. :type toVertex: list. :return: Counts of triangles per edge. """ iEdge = ovl.position_in(toVertex.shape)[0] count = ovl.output(toVertex.shape, ovl.uint64) nTriangle = ovl.variable(0, ovl.uint64) iFromVertex = ovl.variable(fromVertex[iEdge], fromVertex.dtype) iFromEdge = ovl.variable(startEdge[iFromVertex], startEdge.dtype) iFromEdgeEnd = ovl.variable(startEdge[iFromVertex + 1], startEdge.dtype) iiFromVertex = ovl.variable(toVertex[iFromEdge], toVertex.dtype) iToVertex = ovl.variable(toVertex[iEdge], toVertex.dtype) iToEdge = ovl.variable(startEdge[iToVertex], startEdge.dtype) iToEdgeEnd = ovl.variable(startEdge[iToVertex + 1], startEdge.dtype) iiToVertex = ovl.variable(toVertex[iToEdge], toVertex.dtype) nMerge = iToEdgeEnd-iToEdge + iFromEdgeEnd-iFromEdge # Maximum number of merges. # This construction is a work-around for simulating the function of a while loop. #TODO([email protected]): Replace this construct by a while loop once it is available in ovl. for iMerge in ovl.arange(nMerge): doMerge = ovl.logical_and(iFromEdge < iFromEdgeEnd, iToEdge < iToEdgeEnd) doMerge = ovl.logical_and(doMerge, iiFromVertex < iToVertex) with ovl.if_(doMerge): with ovl.if_(iiFromVertex < iiToVertex): iFromEdge <<= iFromEdge+1 iiFromVertex <<= toVertex[iFromEdge] with ovl.elif_(iiFromVertex > iiToVertex): iToEdge <<= iToEdge+1 iiToVertex <<= toVertex[iToEdge] with ovl.else_(): nTriangle <<= nTriangle+1 iFromEdge <<= iFromEdge+1 iToEdge <<= iToEdge+1 iiFromVertex <<= toVertex[iFromEdge] iiToVertex <<= toVertex[iToEdge] #TODO([email protected]): Use a reduction function that computes a partial or complete sum. count[iEdge] = nTriangle # Save the triangles for each edge. return count
def conv_1d(x, v, kernel_orientation='as-is', stride=1, mode='same', data_format='NCE'): """ Define the operator function. :param x: An input tensor of shape [num_batches, num_channels, num_elements]. :param v: A filter/kernel of shape [num_filters, num_channels, kernel_size]. :param kernel_orientation: The orientation of the kernel to use: 'as-is' or 'flipped'. This language is used rather than 'convolution' or 'cross-correlation' since the terms have become overloaded and ambiguous across some fields. As defined in https://en.wikipedia.org/wiki/Cross-correlation#Properties, 'as-is' yields the cross-correlation and 'flipped' yields the convolution. :param stride: kernel stride to use. :param mode: border mode: 'same', 'valid', or 'full' :param data_format: order of the dimensions in the input: 'NCE', 'NEC' etc. :return: an output tensor of shape [num_batches, num_filters, num_elements] """ if kernel_orientation != 'as-is' and kernel_orientation != 'flipped': raise ValueError("kernel_orientation must be 'as-is' or 'flipped'") # resolve data layout based on data_format input assert x.rank == 3 assert len(data_format) == 3 assert data_format.count('N') == 1 assert data_format.count('C') == 1 assert data_format.count('E') == 1 n_axis = data_format.find('N') c_axis = data_format.find('C') e_axis = data_format.find('E') num_elements = x.shape[e_axis] num_channels = x.shape[c_axis] num_batches = x.shape[n_axis] assert v.rank == 3 if num_channels != v.shape[c_axis]: raise ValueError('Channel axis size of input must match that of the filter.') num_filters = v.shape[n_axis] filter_size = v.shape[e_axis] left_apron = filter_size // 2 right_apron = filter_size - left_apron - 1 if not isinstance(stride, int) or stride < 1 or stride > num_elements: raise ValueError('Stride must be a positive integer') if mode == 'same': if filter_size > num_elements: raise ValueError('filter size, ' + str(filter_size) + ', cannot be larger than number of elements, ' + str(num_elements)) starting_element = -left_apron ending_element = num_elements - left_apron elif mode == 'valid': if filter_size > num_elements: raise ValueError('filter size, ' + str(filter_size) + ', cannot be larger than number of elements, ' + str(num_elements)) starting_element = 0 ending_element = num_elements - (left_apron + right_apron) elif mode == 'full': starting_element = -(filter_size - 1) ending_element = num_elements else: raise ValueError("mode must be 'same', 'valid', or 'full'.") output_elements = (ending_element - starting_element) output_shape = [0, 0, 0] output_shape[n_axis] = num_batches output_shape[c_axis] = num_filters output_shape[e_axis] = output_elements output = ovl.output(output_shape, x.dtype) filters_per_worker = 1 filter_workers, filter_remainder = divmod(num_filters, filters_per_worker) if filter_remainder > 0: filter_workers += 1 batches_per_worker = 1 batch_workers, batch_remainder = divmod(num_batches, batches_per_worker) if batch_remainder > 0: batch_workers += 1 elements_per_worker = 10 element_workers, element_remainder = divmod(output_elements, elements_per_worker) if element_remainder > 0: element_workers += 1 workgroup_shape = [batch_workers, filter_workers, element_workers] ovl.logger.debug(u' workgroup_shape: ' + str(workgroup_shape)) pos = ovl.position_in(workgroup_shape) cur_batch_block = pos[0] cur_filter_block = pos[1] cur_element_block = pos[2] num_block_batches = ovl.variable(batches_per_worker, ovl.uint32) if batch_remainder > 0: with ovl.if_(cur_batch_block == batch_workers-1): num_block_batches <<= batch_remainder num_block_filters = ovl.variable(filters_per_worker, ovl.uint32) if filter_remainder > 0: with ovl.if_(cur_filter_block == filter_workers-1): num_block_filters <<= filter_remainder num_block_elements = ovl.variable(elements_per_worker, ovl.uint32) if element_remainder > 0: with ovl.if_(cur_element_block == element_workers-1): num_block_elements <<= element_remainder accum = ovl.zeros((batches_per_worker, filters_per_worker, elements_per_worker), ovl.float64) #4*4 filter_block = ovl.zeros((filters_per_worker, filter_size), v.dtype) #4*10 input_block = ovl.zeros((batches_per_worker, filter_size), x.dtype) #4*10 for cur_channel in ovl.arange(num_channels): # load all filters for this channel for intra_block_filter in ovl.arange(filters_per_worker): for f_pos in ovl.arange(filter_size): filter_index = [None, None, None] filter_index[c_axis] = cur_channel filter_index[n_axis] = ovl.cast(intra_block_filter, ovl.uint32) + cur_filter_block * filters_per_worker if kernel_orientation == 'as-is': filter_index[e_axis] = f_pos elif kernel_orientation == 'flipped': filter_index[e_axis] = filter_size - f_pos - 1 else: raise ValueError("kernel_orientation must be 'as-is' or 'flipped'") filter_block[intra_block_filter, f_pos] = v[filter_index] # load initial inputs for this channel buffer_head = ovl.variable(0, ovl.uint32) for intra_block_batch in ovl.arange(num_block_batches): cur_batch = intra_block_batch + cur_batch_block*batches_per_worker for f_pos in ovl.arange(filter_size): x_index = [None, None, None] x_index[c_axis] = cur_channel x_index[n_axis] = cur_batch x_elem_index = starting_element + ovl.cast(cur_element_block * elements_per_worker, ovl.uint64) + ovl.cast(f_pos, ovl.uint64) x_index[e_axis] = x_elem_index index_in_bounds = ovl.logical_and(x_elem_index >= 0, x_elem_index < num_elements) with ovl.if_(index_in_bounds): input_block[intra_block_batch, f_pos] = x[x_index] with ovl.else_(): input_block[intra_block_batch, f_pos] = 0 for intra_block_element in ovl.arange(num_block_elements): cur_elem = intra_block_element + cur_element_block*elements_per_worker for intra_block_batch in ovl.arange(num_block_batches): cur_batch = intra_block_batch + cur_batch_block*batches_per_worker for intra_block_filter in ovl.arange(num_block_filters): for f_pos in ovl.arange(filter_size): x_pos = (buffer_head + ovl.cast(f_pos, ovl.uint32)) % filter_size cur_x = ovl.cast(input_block[intra_block_batch, x_pos], ovl.float64) cur_v = ovl.cast(filter_block[intra_block_filter, f_pos], ovl.float64) accum[intra_block_batch, intra_block_filter, intra_block_element] = \ accum[intra_block_batch, intra_block_filter, intra_block_element] + cur_x * cur_v # load new element x_index = [None, None, None] x_index[c_axis] = cur_channel x_index[n_axis] = cur_batch x_elem_index = starting_element + cur_elem + filter_size x_index[e_axis] = x_elem_index index_in_bounds = ovl.logical_and(x_elem_index >= 0, x_elem_index < num_elements) with ovl.if_(index_in_bounds): input_block[intra_block_batch, buffer_head] = x[x_index] with ovl.else_(): input_block[intra_block_batch, buffer_head] = 0 buffer_head <<= (buffer_head + 1) % filter_size for intra_block_batch in ovl.arange(num_block_batches): cur_batch = intra_block_batch + cur_batch_block*batches_per_worker for intra_block_filter in ovl.arange(num_block_filters): cur_filter = intra_block_filter + cur_filter_block*filters_per_worker for intra_block_element in ovl.arange(num_block_elements): cur_elem = intra_block_element + cur_element_block*elements_per_worker output_index = [None, None, None] output_index[n_axis] = cur_batch output_index[e_axis] = cur_elem output_index[c_axis] = cur_filter output[output_index] = ovl.cast(accum[intra_block_batch, intra_block_filter, intra_block_element], output.dtype) return output
def op(self, input0, input1, input2, input3, input4): sum = ops.output_like(input0) pos = ops.position_in(input0.shape) sum[pos] = input0[pos] + input1[pos] + input2[pos] + input3[pos] + input4[pos] return sum
def conv_1d(x, v, kernel_orientation='as-is', stride=1, mode='same', data_format='NCE'): """ Define the operator function. :param x: An input tensor of shape [num_batches, num_channels, num_elements]. :param v: A filter/kernel of shape [num_filters, num_channels, kernel_size]. :param kernel_orientation: The orientation of the kernel to use: 'as-is' or 'flipped'. This language is used rather than 'convolution' or 'cross-correlation' since the terms have become overloaded and ambiguous across some fields. As defined in https://en.wikipedia.org/wiki/Cross-correlation#Properties, 'as-is' yields the cross-correlation and 'flipped' yields the convolution. :param stride: kernel stride to use. :param mode: border mode: 'same', 'valid', or 'full' :param data_format: order of the dimensions in the input: 'NCE', 'NEC' etc. :return: an output tensor of shape [num_batches, num_filters, num_elements] """ if kernel_orientation != 'as-is' and kernel_orientation != 'flipped': raise ValueError("kernel_orientation must be 'as-is' or 'flipped'") # resolve data layout based on data_format input assert x.rank == 3 assert len(data_format) == 3 assert data_format.count('N') == 1 assert data_format.count('C') == 1 assert data_format.count('E') == 1 n_axis = data_format.find('N') c_axis = data_format.find('C') e_axis = data_format.find('E') num_elements = x.shape[e_axis] num_channels = x.shape[c_axis] num_batches = x.shape[n_axis] assert v.rank == 3 if num_channels != v.shape[c_axis]: raise ValueError( 'Channel axis size of input must match that of the filter.') num_filters = v.shape[n_axis] filter_size = v.shape[e_axis] left_apron = filter_size // 2 right_apron = filter_size - left_apron - 1 if not isinstance(stride, int) or stride < 1 or stride > num_elements: raise ValueError('Stride must be a positive integer') if mode == 'same': if filter_size > num_elements: raise ValueError('filter size, ' + str(filter_size) + ', cannot be larger than number of elements, ' + str(num_elements)) starting_element = -left_apron ending_element = num_elements - left_apron elif mode == 'valid': if filter_size > num_elements: raise ValueError('filter size, ' + str(filter_size) + ', cannot be larger than number of elements, ' + str(num_elements)) starting_element = 0 ending_element = num_elements - (left_apron + right_apron) elif mode == 'full': starting_element = -(filter_size - 1) ending_element = num_elements else: raise ValueError("mode must be 'same', 'valid', or 'full'.") output_elements = (ending_element - starting_element) output_shape = [0, 0, 0] output_shape[n_axis] = num_batches output_shape[c_axis] = num_filters output_shape[e_axis] = output_elements output = ovl.output(output_shape, x.dtype) filters_per_worker = 1 filter_workers, filter_remainder = divmod(num_filters, filters_per_worker) if filter_remainder > 0: filter_workers += 1 batches_per_worker = 1 batch_workers, batch_remainder = divmod(num_batches, batches_per_worker) if batch_remainder > 0: batch_workers += 1 elements_per_worker = 10 element_workers, element_remainder = divmod(output_elements, elements_per_worker) if element_remainder > 0: element_workers += 1 workgroup_shape = [batch_workers, filter_workers, element_workers] ovl.logger.debug(u' workgroup_shape: ' + str(workgroup_shape)) pos = ovl.position_in(workgroup_shape) cur_batch_block = pos[0] cur_filter_block = pos[1] cur_element_block = pos[2] num_block_batches = ovl.variable(batches_per_worker, ovl.uint32) if batch_remainder > 0: with ovl.if_(cur_batch_block == batch_workers - 1): num_block_batches <<= batch_remainder num_block_filters = ovl.variable(filters_per_worker, ovl.uint32) if filter_remainder > 0: with ovl.if_(cur_filter_block == filter_workers - 1): num_block_filters <<= filter_remainder num_block_elements = ovl.variable(elements_per_worker, ovl.uint32) if element_remainder > 0: with ovl.if_(cur_element_block == element_workers - 1): num_block_elements <<= element_remainder accum = ovl.zeros( (batches_per_worker, filters_per_worker, elements_per_worker), ovl.float64) #4*4 filter_block = ovl.zeros((filters_per_worker, filter_size), v.dtype) #4*10 input_block = ovl.zeros((batches_per_worker, filter_size), x.dtype) #4*10 for cur_channel in ovl.arange(num_channels): # load all filters for this channel for intra_block_filter in ovl.arange(filters_per_worker): for f_pos in ovl.arange(filter_size): filter_index = [None, None, None] filter_index[c_axis] = cur_channel filter_index[n_axis] = ovl.cast( intra_block_filter, ovl.uint32) + cur_filter_block * filters_per_worker if kernel_orientation == 'as-is': filter_index[e_axis] = f_pos elif kernel_orientation == 'flipped': filter_index[e_axis] = filter_size - f_pos - 1 else: raise ValueError( "kernel_orientation must be 'as-is' or 'flipped'") filter_block[intra_block_filter, f_pos] = v[filter_index] # load initial inputs for this channel buffer_head = ovl.variable(0, ovl.uint32) for intra_block_batch in ovl.arange(num_block_batches): cur_batch = intra_block_batch + cur_batch_block * batches_per_worker for f_pos in ovl.arange(filter_size): x_index = [None, None, None] x_index[c_axis] = cur_channel x_index[n_axis] = cur_batch x_elem_index = starting_element + ovl.cast( cur_element_block * elements_per_worker, ovl.uint64) + ovl.cast(f_pos, ovl.uint64) x_index[e_axis] = x_elem_index index_in_bounds = ovl.logical_and(x_elem_index >= 0, x_elem_index < num_elements) with ovl.if_(index_in_bounds): input_block[intra_block_batch, f_pos] = x[x_index] with ovl.else_(): input_block[intra_block_batch, f_pos] = 0 for intra_block_element in ovl.arange(num_block_elements): cur_elem = intra_block_element + cur_element_block * elements_per_worker for intra_block_batch in ovl.arange(num_block_batches): cur_batch = intra_block_batch + cur_batch_block * batches_per_worker for intra_block_filter in ovl.arange(num_block_filters): for f_pos in ovl.arange(filter_size): x_pos = (buffer_head + ovl.cast(f_pos, ovl.uint32)) % filter_size cur_x = ovl.cast(input_block[intra_block_batch, x_pos], ovl.float64) cur_v = ovl.cast( filter_block[intra_block_filter, f_pos], ovl.float64) accum[intra_block_batch, intra_block_filter, intra_block_element] = \ accum[intra_block_batch, intra_block_filter, intra_block_element] + cur_x * cur_v # load new element x_index = [None, None, None] x_index[c_axis] = cur_channel x_index[n_axis] = cur_batch x_elem_index = starting_element + cur_elem + filter_size x_index[e_axis] = x_elem_index index_in_bounds = ovl.logical_and(x_elem_index >= 0, x_elem_index < num_elements) with ovl.if_(index_in_bounds): input_block[intra_block_batch, buffer_head] = x[x_index] with ovl.else_(): input_block[intra_block_batch, buffer_head] = 0 buffer_head <<= (buffer_head + 1) % filter_size for intra_block_batch in ovl.arange(num_block_batches): cur_batch = intra_block_batch + cur_batch_block * batches_per_worker for intra_block_filter in ovl.arange(num_block_filters): cur_filter = intra_block_filter + cur_filter_block * filters_per_worker for intra_block_element in ovl.arange(num_block_elements): cur_elem = intra_block_element + cur_element_block * elements_per_worker output_index = [None, None, None] output_index[n_axis] = cur_batch output_index[e_axis] = cur_elem output_index[c_axis] = cur_filter output[output_index] = ovl.cast( accum[intra_block_batch, intra_block_filter, intra_block_element], output.dtype) return output
def graph_triangle_count(startEdge, fromVertex, toVertex): """Counts the triangles in an undirected graph. Notice that this method assumes that the graph is given as an adjacency list where all lists with vertex neighbors are sorted. The parallel algorithm uses the following strategy. We map one thread per edge, This is also called the edge-based iterator strategy. The idea behind the algorithm is: 1. Go over all edges (u, v). 2. The neighboring indices for vertex u are N(u) and for vertex v are N(v). 3. Increment the triangle counter by | N(u) /\ N(v) | where /\ is the set intersection operator. We enforce an order on the vertices that avoids counting the same triangle three times, instead each triangle is counted once. Attributes: None. The array toVertex is a flattened list of lists structure, where startEdge encodes the start indices of the separate lists. :param startEdge: Indices into toVertex where edges start. :type startEdge: list. :param fromVertex: The from-vertex of each edge. :type fromVertex: list. :param toVertex: The to-vertex of each edge. :type toVertex: list. :return: Counts of triangles per edge. """ iEdge = ovl.position_in(toVertex.shape)[0] count = ovl.output(toVertex.shape, ovl.uint64) nTriangle = ovl.variable(0, ovl.uint64) iFromVertex = ovl.variable(fromVertex[iEdge], fromVertex.dtype) iFromEdge = ovl.variable(startEdge[iFromVertex], startEdge.dtype) iFromEdgeEnd = ovl.variable(startEdge[iFromVertex + 1], startEdge.dtype) iiFromVertex = ovl.variable(toVertex[iFromEdge], toVertex.dtype) iToVertex = ovl.variable(toVertex[iEdge], toVertex.dtype) iToEdge = ovl.variable(startEdge[iToVertex], startEdge.dtype) iToEdgeEnd = ovl.variable(startEdge[iToVertex + 1], startEdge.dtype) iiToVertex = ovl.variable(toVertex[iToEdge], toVertex.dtype) nMerge = iToEdgeEnd - iToEdge + iFromEdgeEnd - iFromEdge # Maximum number of merges. # This construction is a work-around for simulating the function of a while loop. #TODO([email protected]): Replace this construct by a while loop once it is available in ovl. for iMerge in ovl.arange(nMerge): doMerge = ovl.logical_and(iFromEdge < iFromEdgeEnd, iToEdge < iToEdgeEnd) doMerge = ovl.logical_and(doMerge, iiFromVertex < iToVertex) with ovl.if_(doMerge): with ovl.if_(iiFromVertex < iiToVertex): iFromEdge <<= iFromEdge + 1 iiFromVertex <<= toVertex[iFromEdge] with ovl.elif_(iiFromVertex > iiToVertex): iToEdge <<= iToEdge + 1 iiToVertex <<= toVertex[iToEdge] with ovl.else_(): nTriangle <<= nTriangle + 1 iFromEdge <<= iFromEdge + 1 iToEdge <<= iToEdge + 1 iiFromVertex <<= toVertex[iFromEdge] iiToVertex <<= toVertex[iToEdge] #TODO([email protected]): Use a reduction function that computes a partial or complete sum. count[iEdge] = nTriangle # Save the triangles for each edge. return count