How to use the cgt.shape function in cgt

def shp_apply(self, inputs):
        return (cgt.shape(inputs[0]), cgt.shape(inputs[0]))
    def get_py_impl(self):

def sample(self, p, shape=None):
        p = core.as_node(p)
        shape = shape or cgt.shape(p)
        return cgt.rand(*shape) <= p

def shp_apply(self, parents):
        if self.shapefun:
            return self.shapefun(parents)
        else:
            return cgt.shape(self)
    def typ_apply(self, _parents):

for node in nodes_sorted:

        base = node # by default, 
        if node.is_argument():
            pass
        elif node.op.writes_to_input >= 0:
            base = node2memowner[node.parents[node.op.writes_to_input]]
        elif node in after2before:
            base = after2before[node]
        elif enable_inplace_opt and node.op.return_type == "byref": # TODO think about if we need any other conditions
            nodeshape = node.op.shp_apply(node.parents)
            for parent in node.parents:
                parentowner = node2memowner[parent]
                if (len(node2child[parent])==1
                        and nodeshape==cgt.shape(parent) # XXX not a very robust way to check
                        and node.dtype == parent.dtype
                        and _is_data_mutable(parentowner)
                        and parent not in outputs
                        ):
                    base = parentowner
                    break
        # TODO: add optimization for in-place incrementing
        node2memowner[node] = base

    return node2memowner

def _subtensor2(x, slis, y):

    dims2drop = []
    for (ax,sli) in enumerate(slis):
        if _is_int_scalar(sli):
            if y is None:
                dims2drop.append(ax)
            else:
                yshape = cgt.shape(y)
                yshape.insert(ax, 1)
                y = y.reshape(yshape)
            sli = slice(sli, sli + 1, 1)

        assert isinstance(sli.step, int) or sli.step is None
        step = 1 if sli.step is None else sli.step

        if step < 0:
            start = size(x, ax)-1 if sli.start is None else sli.start
            stop = -1 if sli.stop is None else sli.stop
        else:
            start = 0 if sli.start is None else sli.start
            stop = size(x, ax) if sli.stop is None else sli.stop

        assert isinstance(step, (int, core.Node)), "step argument of a slice should be an integer or a symbolic variable"

def shp_apply(self, inputs):
        return cgt.shape(inputs[0])
    def typ_apply(self, inputs):

            shapefun = lambda *args : tuple(cgt.shape(x) for x in inputs)  )
        return cgt.core.unpack(core.Result(pbop, inputs + [output, goutput]))

def shp_apply(self, inputs):
        # pooled_height_ = static_cast(ceil(static_cast(height_ + 2 * pad_h_ - kernel_h_) / stride_h_)) + 1;
        # pooled_width_ = static_cast(ceil(static_cast(width_ + 2 * pad_w_ - kernel_w_) / stride_w_)) + 1;
        info = self.info
        batch_size, channels, height, width = cgt.shape(inputs[0])
        pooled_height =  cgt.ceil_divide(height + 2*info.pad_h - info.kernel_h, info.stride_h)
        pooled_width = cgt.ceil_divide(width + 2*info.pad_w - info.kernel_w, info.stride_w)
        outshape = [batch_size ,  channels, pooled_height, pooled_width]
        return (outshape, outshape)
    def typ_apply(self, inputs):