def mlhw6p17():
    trainD = readTrainData()
    testD  = readTestData()

    # training 
    forest = randomForest(trainD)
    
    # testing
    result = testEachTreeInForest(forest,testD)

    eouts = map(lambda r:r["err"],result)
    eouts.sort()

    print "histogram"
    his = histogram(eouts)
    # Show histogram
    for key in his:
        print "[%3d%%,%3d%%) |%s %d (%.0f%%)" % (key,key+1,"|"*his[key],his[key],float(his[key])*100/len(eouts))


    for i in xrange(len(forest)):
        ein  = testForest(forest[0:i+1],trainD)
        eout = testForest(forest[0:i+1],testD)
        ein = ein["err"]
        eout = eout["err"]
        print "%d,%.4f,%.4f" % (i+1,ein,eout)
Exemple #2
0
def mlhw6p16():
    trainD = readTrainData()
    testD = readTestData()

    dt = CART(trainD)

    travel(dt)

    eintest = testing(dt, trainD)
    print eintest
    eouttest = testing(dt, testD)
    print eouttest
Exemple #3
0
def mlhw6p16():
    trainD = readTrainData()
    testD  = readTestData()

    dt = CART(trainD)
    
    travel(dt)

    eintest = testing(dt,trainD)
    print eintest
    eouttest = testing(dt,testD)
    print eouttest
def mlhw6p10():
    trainD = readTrainData()
    testD = readTestData()

    G, U = adaboost(trainD, 300)

    print "testing..."

    # P10/11
    for i in range(1, 300):
        ein = adaboostTest(trainD, G[0:i])
        eout = adaboostTest(testD, G[0:i])
        print "%03d,%.6f,%.6f" % (i, ein, eout)
def mlhw6p10():
    trainD = readTrainData()
    testD  = readTestData()

    G,U = adaboost(trainD,300)

    print "testing..."

    # P10/11
    for i in range(1,300):
        ein = adaboostTest(trainD,G[0:i])
        eout = adaboostTest(testD,G[0:i])
        print "%03d,%.6f,%.6f" % (i,ein,eout)
def main(argv=None):

    q_in = Queue()
    q_cam = Queue()
    q_pred = Queue()

    processes = []
    p_inference = Process(target=run_inference, args=(q_in, q_cam, q_pred))
    p_gui = Process(target=run_gui, args=(q_cam, q_pred))

    if FLAGS.mode == "stream":
        p_inference.start()
        processes.append(p_inference)

        p_gui.start()
        processes.append(p_gui)

        cap = cv2.VideoCapture(0)

        while (True):
            # Capture frame-by-frame
            _, frame = cap.read()
            if FLAGS.resize_image:
                frame = cv2.resize(frame,
                                   (FLAGS.image_width, FLAGS.image_height))
            q_in.put(frame)

        cap.release()
        cv2.destroyAllWindows()

        for p in processes:
            p.join()

    elif FLAGS.mode == 'video':

        video_path = os.path.join(dir_path, FLAGS.path_to_video_input)
        if not os.path.exists(video_path):
            raise Exception(
                "Error: unable to find video on provided path - %s" %
                FLAGS.path_to_video_input)

        p_inference.start()
        processes.append(p_inference)

        cap = cv2.VideoCapture(FLAGS.path_to_video_input)

        total_frames = cap.get(cv2.CAP_PROP_FRAME_COUNT)
        video_fps = cap.get(cv2.CAP_PROP_FPS)
        print('Input video FPS: %d' % video_fps)

        fourcc = cv2.VideoWriter_fourcc(*'DIVX')
        if FLAGS.resize_image:
            out_video = cv2.VideoWriter(
                os.path.join(dir_path, FLAGS.path_to_video_output), fourcc,
                video_fps, (FLAGS.image_width, FLAGS.image_height))
        else:
            image_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
            image_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
            out_video = cv2.VideoWriter(
                os.path.join(dir_path, FLAGS.path_to_video_output), fourcc,
                video_fps, (image_width, image_height))

        frames_processed = 0
        time_start = time.time()
        while (cap.isOpened()):
            ret, frame = cap.read()

            if ret:
                if FLAGS.resize_image:
                    frame = cv2.resize(frame,
                                       (FLAGS.image_width, FLAGS.image_height))
                q_in.put(frame)
                time_start = time.time()
            elif time.time() - time_start > 5:
                break

            while q_in.qsize() > 100:
                sleep(0.2)

            if not q_pred.empty():
                frames_processed += 1
                pred = q_pred.get()
                out_video.write(pred)
                print('Progress: %f %%' %
                      (100 * frames_processed / total_frames))

        out_video.release()

    elif FLAGS.mode == "test":
        print('Loading test images...')
        test_images_orig, file_names = utils.readTestData(
            FLAGS.test_dir_input, FLAGS.input_size)

        p_inference.start()
        processes.append(p_inference)

        for i in range(len(file_names)):
            image = test_images_orig[i]
            fname = file_names[i]

            if FLAGS.resize_image:
                image = cv2.resize(image,
                                   (FLAGS.image_width, FLAGS.image_height))

            q_in.put(image)
            pred = q_pred.get(block=True)
            cv2.imwrite(
                os.path.join(FLAGS.test_dir_output, fname) + '.png', pred)
            print('Image processed: %s' % fname)

    else:
        raise Exception('Error: unknown value for argument mode')

    for p in processes:
        p.terminate()