예제 #1
0
def train(model="categorizer", file_x="data-x.csv", file_y="data-y.csv"):
    x = tf.contrib.learn.datasets.base.load_csv_without_header(
        filename=file_x, target_dtype=np.float32, features_dtype=np.float32)
    old_x = concatenate((mat(x.data), mat(x.target).T), axis=1)
    x = old_x[:, 1:]

    y = tf.contrib.learn.datasets.base.load_csv_without_header(
        filename=file_y, target_dtype=np.int32, features_dtype=np.int32)
    y = mat(y.target).T

    if shape(x)[0] != shape(y)[0]:
        raise NameError('matrices do not match!')

    data = concatenate((x, y), axis=1)

    data = parse.shuffle(data)

    train, test = parse.split(data)
    trainX, trainY = parse.splitLabels(train)
    testX, testY = parse.splitLabels(test)

    featureCount = shape(trainX)[1]

    print 'feature count ' + str(featureCount)
    print 'training set ' + str(shape(trainX)[0])
    print 'testing set ' + str(shape(testX)[0])

    classifier = common.prepare_classifier("./" + model + "-model",
                                           featureCount)

    print 'Training start'
    classifier.fit(x=trainX, y=trainY, steps=2000)
    print 'Training done'

    accuracy_score = classifier.evaluate(x=testX, y=testY)["accuracy"]
    print('Accuracy: {0:f}'.format(accuracy_score))
예제 #2
0
def src2blocks(source):
    exprs, lines = parse.split(source)
    root = parse.parse(exprs)
    translate.translate(root)
    syntax.check_syntax(root)
    return root, lines
예제 #3
0
    def next(self):
        from parse import split

        ndleft = mx.nd.zeros((self.batch_size * self.data_frames, 3,
                              self.data_shape[1], self.data_shape[0]))
        if self.upsample > 1:
            left0 = np.zeros(
                (self.batch_size, self.data_shape[1] * self.upsample,
                 self.data_shape[0] * self.upsample, 3),
                dtype=np.float32)
        else:
            ndleft0 = mx.nd.zeros(
                (self.batch_size, 3, self.data_shape[1], self.data_shape[0]))
        if self.flow_frames > 0:
            ndflow = mx.nd.zeros((self.batch_size * self.flow_frames, 2,
                                  self.data_shape[1], self.data_shape[0]))
        right = np.zeros((self.batch_size, self.data_shape[1] * self.upsample,
                          self.data_shape[0] * self.upsample, 3),
                         dtype=np.float32)
        if self.output_depth:
            depth = np.zeros(
                (self.batch_size, self.data_shape[1] * self.data_shape[0]),
                dtype=np.float32)

        with self.env.begin() as txn:
            for i in range(self.batch_size):
                if self.cur >= len(self.idx):
                    i -= 1
                    break
                idx = self.idx[self.cur]
                if self.upsample > 1:
                    nidx = int(idx)
                    mov = nidx / 1000000
                    nframe = nidx % 1000000
                    nframe = nframe / 10000 * 3 * 24 * 60 + nframe % 10000
                    if self.caps[mov].get(cv2.CAP_PROP_POS_FRAMES) != nframe:
                        print('seek', nframe)
                        self.caps[mov].set(cv2.CAP_PROP_POS_FRAMES, nframe)
                    ret, frame = self.caps[mov].read()
                    assert ret
                    margin = (frame.shape[0] - 800) / 2
                    lframe, rframe = split(frame,
                                           reshape=self.base_shape,
                                           vert=True,
                                           clip=(0, margin, 960, margin + 800))

                p = self.fix_p
                if self.output_depth:
                    sd = txn.get('%09d' % idx, db=self.ddb)
                    assert sd is not None
                    _, dimg = mx.recordio.unpack_img(sd, -1)
                    dimg, p = crop_img(dimg,
                                       p,
                                       self.data_shape,
                                       self.margin,
                                       test=self.test_mode)
                    depth[i] = dimg.flat

                if self.upsample > 1:
                    rimg, p = crop_img(rframe,
                                       p, (self.data_shape[0] * self.upsample,
                                           self.data_shape[1] * self.upsample),
                                       0,
                                       test=self.test_mode,
                                       grid=self.upsample)
                    right[i] = rimg
                else:
                    sr = txn.get('%09d' % idx, db=self.rdb)
                    assert sr is not None
                    _, rimg = mx.recordio.unpack_img(sr, 1)
                    rimg, p = crop_img(rimg,
                                       p,
                                       self.data_shape,
                                       0,
                                       test=self.test_mode)
                    right[i] = rimg

                for j in range(max(1, self.data_frames)):
                    sl = txn.get('%09d' %
                                 (idx +
                                  (j - self.data_frames / 2) * self.stride),
                                 db=self.ldb)
                    if sl is None:
                        pass
                    else:
                        _, s = mx.recordio.unpack(sl)
                        mx.nd.imdecode(s,
                                       clip_rect=(p[0], p[1],
                                                  p[0] + self.data_shape[0],
                                                  p[1] + self.data_shape[1]),
                                       out=ndleft,
                                       index=i * self.data_frames + j,
                                       channels=3,
                                       mean=self.left_mean_nd)

                if self.upsample > 1:
                    limg, p = crop_img(lframe,
                                       p, (self.data_shape[0] * self.upsample,
                                           self.data_shape[1] * self.upsample),
                                       0,
                                       test=self.test_mode,
                                       grid=self.upsample)
                    left0[i] = limg
                else:
                    start = i * max(1, self.data_frames) + max(
                        1, self.data_frames) / 2
                    ndleft0[i:(
                        i +
                        1)] = ndleft[start:(start + 1)] + self.left_mean_nd_1

                for j in range(self.flow_frames):
                    sf = txn.get('%09d' %
                                 (idx +
                                  (j - self.flow_frames / 2) * self.stride),
                                 db=self.fdb)
                    if sf is None:
                        pass
                    else:
                        _, s = mx.recordio.unpack(sf)
                        mx.nd.imdecode(s,
                                       clip_rect=(p[0], p[1],
                                                  p[0] + self.data_shape[0],
                                                  p[1] + self.data_shape[1]),
                                       out=ndflow,
                                       index=i * self.flow_frames + j,
                                       channels=2,
                                       mean=self.flow_mean_nd)
                self.cur += 1

        data = []
        if self.data_frames > 0:
            ndleft = ndleft.reshape((self.batch_size, self.data_frames * 3,
                                     self.data_shape[1], self.data_shape[0]))
            data.append(ndleft)
        if self.flow_frames > 0:
            ndflow = ndflow.reshape((self.batch_size, self.flow_frames * 2,
                                     self.data_shape[1], self.data_shape[0]))
            data.append(ndflow)
        if self.upsample > 1:
            data.append(mx.nd.array(left0.transpose((0, 3, 1, 2))))
        elif not self.no_left0:
            data.append(ndleft0)
        right = right.transpose((0, 3, 1, 2))
        if self.right_whiten:
            right -= self.right_mean

        i += 1
        pad = self.batch_size - i
        if pad:
            raise StopIteration
        if self.output_depth:
            return mx.io.DataBatch(
                data,
                [mx.nd.array(right), mx.nd.array(depth)], pad, None)
        else:
            return mx.io.DataBatch(data, [mx.nd.array(right)], pad, None)
예제 #4
0
def src2blocks(source):
    exprs,lines = parse.split(source)
    root = parse.parse(exprs)
    translate.translate(root)
    syntax.check_syntax(root)
    return root,lines
예제 #5
0
파일: data.py 프로젝트: Creatrol/deep3d
    def next(self):
        from parse import split

        ndleft = mx.nd.zeros((self.batch_size*self.data_frames, 3, self.data_shape[1], self.data_shape[0]))
        if self.upsample > 1:
            left0 = np.zeros((self.batch_size, self.data_shape[1]*self.upsample, self.data_shape[0]*self.upsample, 3), dtype=np.float32)
        else:
            ndleft0 = mx.nd.zeros((self.batch_size, 3, self.data_shape[1], self.data_shape[0]))
        if self.flow_frames > 0:
            ndflow = mx.nd.zeros((self.batch_size*self.flow_frames, 2, self.data_shape[1], self.data_shape[0]))
        right = np.zeros((self.batch_size, self.data_shape[1]*self.upsample, self.data_shape[0]*self.upsample, 3), dtype=np.float32)
        if self.output_depth:
            depth = np.zeros((self.batch_size, self.data_shape[1]*self.data_shape[0]), dtype=np.float32)


        with self.env.begin() as txn:    
            for i in range(self.batch_size):
                if self.cur >= len(self.idx):
                    i -= 1
                    break
                idx = self.idx[self.cur]
                if self.upsample > 1:
                    nidx = int(idx)
                    mov = nidx/1000000
                    nframe = nidx%1000000
                    nframe = nframe/10000*3*24*60 + nframe%10000
                    if self.caps[mov].get(cv2.CAP_PROP_POS_FRAMES) != nframe:
                        print 'seek', nframe
                        self.caps[mov].set(cv2.CAP_PROP_POS_FRAMES, nframe)
                    ret, frame = self.caps[mov].read()
                    assert ret
                    margin = (frame.shape[0] - 800)/2
                    lframe, rframe = split(frame, reshape=self.base_shape, vert=True, clip=(0, margin, 960, margin+800))

                p = self.fix_p
                if self.output_depth:
                    sd = txn.get('%09d'%idx, db=self.ddb)
                    assert sd is not None
                    _, dimg = mx.recordio.unpack_img(sd, -1)
                    dimg, p = crop_img(dimg, p, self.data_shape, self.margin, test=self.test_mode)
                    depth[i] = dimg.flat

                if self.upsample > 1:
                    rimg, p = crop_img(rframe, p, (self.data_shape[0]*self.upsample, self.data_shape[1]*self.upsample), 0, test=self.test_mode, grid=self.upsample)
                    right[i] = rimg
                else:
                    sr = txn.get('%09d'%idx, db=self.rdb)
                    assert sr is not None
                    _, rimg = mx.recordio.unpack_img(sr, 1)
                    rimg, p = crop_img(rimg, p, self.data_shape, 0, test=self.test_mode)
                    right[i] = rimg

                for j in range(max(1, self.data_frames)):
                    sl = txn.get('%09d'%(idx+(j-self.data_frames/2)*self.stride), db=self.ldb)
                    if sl is None:
                        pass
                    else:
                        _, s = mx.recordio.unpack(sl)
                        mx.nd.imdecode(s, clip_rect=(p[0], p[1], p[0] + self.data_shape[0], p[1] + self.data_shape[1]),
                                       out=ndleft, index=i*self.data_frames+j, channels=3, mean=self.left_mean_nd)

                if self.upsample > 1:
                    limg, p = crop_img(lframe, p, (self.data_shape[0]*self.upsample, self.data_shape[1]*self.upsample), 0, test=self.test_mode, grid=self.upsample)
                    left0[i] = limg
                else:
                    start = i*max(1, self.data_frames)+max(1, self.data_frames)/2
                    ndleft0[i:(i+1)] = ndleft[start:(start+1)] + self.left_mean_nd_1

                for j in range(self.flow_frames):
                    sf = txn.get('%09d'%(idx+(j-self.flow_frames/2)*self.stride), db=self.fdb)
                    if sf is None:
                        pass
                    else:
                        _, s = mx.recordio.unpack(sf)
                        mx.nd.imdecode(s, clip_rect=(p[0], p[1], p[0] + self.data_shape[0], p[1] + self.data_shape[1]),
                                       out=ndflow, index=i*self.flow_frames+j, channels=2, mean=self.flow_mean_nd)
                self.cur += 1

        data = []
        if self.data_frames > 0:
            ndleft = ndleft.reshape((self.batch_size, self.data_frames*3, self.data_shape[1], self.data_shape[0]))
            data.append(ndleft)
        if self.flow_frames > 0:
            ndflow = ndflow.reshape((self.batch_size, self.flow_frames*2, self.data_shape[1], self.data_shape[0]))
            data.append(ndflow)
        if self.upsample > 1:
            data.append(mx.nd.array(left0.transpose((0, 3, 1, 2))))
        elif not self.no_left0:
            data.append(ndleft0)
        right = right.transpose((0, 3, 1, 2))
        if self.right_whiten:
            right -= self.right_mean

        i += 1
        pad = self.batch_size - i
        if pad:
            raise StopIteration
        if self.output_depth:
            return mx.io.DataBatch(data, [mx.nd.array(right), mx.nd.array(depth)], pad, None)
        else:
            return mx.io.DataBatch(data, [mx.nd.array(right)], pad, None)