Ejemplo n.º 1
0
def model_test(model, input_data, label_data, is_debug=False, line=0.1):
    correct_num = 0
    st2_num = 0
    st3_num = 0
    total_num = len(input_data)
    st1 = np.zeros(64)
    st2 = np.zeros(64)
    st3 = np.zeros(64)
    data_sca = np.zeros(64)
    right_location_num = 0
    for step in range(len(input_data)):
        if is_debug:
            print(
                '\n<----------------------------------------------------------',
                step)
        x = input_data[step:(step + 1)]
        y = label_data[step:(step + 1)]
        max_y_index = 0
        # 求y的最大值下标
        for i in range(len(y[0])):
            if y[0][i] >= y[0][max_y_index]:
                max_y_index = i

        data_sca[max_y_index] = data_sca[max_y_index] + 1

        # x = np.array(x).reshape(1, 1, 64)
        # y = np.array(y).reshape(1, 1, 64)
        x = torch.FloatTensor(x).cuda(0)
        y = torch.ByteTensor(y).cuda(0)
        prediction = model(x)

        predict = torch.sigmoid(prediction) > line

        t = label_data[step:(step + 1)]
        # t=
        t = np.array(t[0]).tolist()
        pd = predict.view(-1).data.cpu().numpy()
        pd = np.array(pd).tolist()
        result = torch.eq(y, predict)
        res = result.view(-1).data.cpu().numpy()
        res = np.array(res).tolist()
        if is_debug:
            print('target:    ', t)
            print('predict:   ', pd)
            print('difference:', res)

        if is_satisfied_standard2(pd, max_y_index):
            st2_num = st2_num + 1
            st2[max_y_index] = st2[max_y_index] + 1
            if is_debug:
                print('st2_right')

        if is_satisfied_standard3(pd, max_y_index):
            st3_num = st3_num + 1
            st3[max_y_index] = st3[max_y_index] + 1
            if is_debug:
                print('st3_right')

        result = torch.eq(y, predict)
        accuracy = torch.sum(result) / torch.sum(torch.ones(y.shape))
        accuracy = accuracy.data.cpu().numpy()
        correct = torch.eq(torch.sum(~result), 0)
        if is_debug:
            print('accuracy: ', accuracy)
            print('correct: {}'.format(correct))
        if correct == 1:
            # right_index = int(max_y_index/10)
            st1[max_y_index] = st1[max_y_index] + 1
            correct_num = correct_num + 1  # 标准1,完全匹配
        if is_debug:
            print(
                '-------------------------------------------------------------->\n'
            )

    if is_debug:
        print('total:', (step + 1), ' | correct_num:', correct_num,
              '| complete_correct_rate:', correct_num / total_num,
              '| st2_num: ', st2_num, ' |st2_rate: ', st2_num / total_num,
              '| st3_num: ', st3_num, ' |st3_rate: ', st3_num / total_num)
        print('st1 : ', st1)
        print('data_sca : ', data_sca)

        # right_distribute.distribute_cv(st1, data_sca, 36, 'cnn_st1完全正确预测分布')
        right_distribute.distribute_cv(st2, data_sca, 36, 'cnn_st2相对预测正确率')
        right_distribute.distribute_cv(st3, data_sca, 36, 'cnn_st3相对预测正确率')

    return correct_num / total_num, st2_num / total_num, st3_num / total_num
Ejemplo n.º 2
0
    if (abs(max_y_index - max_predict_index) < 3):
        relative_correct_num = relative_correct_num + 1
        sca_r[max_y_index] = sca_r[max_y_index] + 1
    # print('max_y_index : ', max_y_index, '  max_predict_index: ', max_predict_index)

    result = torch.eq(y, predict)
    accuracy = torch.sum(result) / torch.sum(torch.ones(y.shape))
    accuracy = accuracy.data.cpu().numpy()
    correct = torch.eq(torch.sum(~result), 0)
    # if math.fabs(0.98437 - accuracy) > 0.0001:
    # print('accuracy: ', accuracy)
    # print('correct: {}'.format(correct))
    if correct == 1:
        # right_index = int(max_y_index/10)
        sca[max_y_index] = sca[max_y_index] + 1
        # sca_r[max_y_index] = sca_r[max_y_index] + 1
        correct_num = correct_num + 1

    # print('-------------------------------------------------------------->\n')

print('total:', (step + 1), ' | correct_num:', correct_num, '| complete_correct_rate:', correct_num / total_num,
      '| relative_correct_num : ', relative_correct_num, '| relative_correct_rate: ', relative_correct_num / total_num)

print('sca : ', sca)
print('sca_r: ', sca_r)
print('data_sca:', data_sca)

right_distribute.distribute_cv(sca, data_sca, 64)
right_distribute.distribute_cv(sca_r, data_sca, 64)
# print('prediction: ', prediction.data.cpu().numpy().flatten())
Ejemplo n.º 3
0
def model_test(model_path):
    print('test')
    model = torch.load(model_path)
    # input_data, label_data = radar_data.load_pg_test_data()
    _, _1, input_data, label_data = radar_data.load_pg_data_by_range(
        0, SEQ_LEN)
    # _, _1, input_data, label_data = radar_data.load_road_data()
    input_data = radar_data.reduce_data_length(input_data, 0, SEQ_LEN)
    label_data = radar_data.reduce_data_length(label_data, 0, SEQ_LEN)
    # L = len(input_data)

    correct_num = 0
    relative_correct_num = 0
    total_num = len(input_data)
    sca = np.zeros(SEQ_LEN)
    sca_r = np.zeros(SEQ_LEN)
    data_sca = np.zeros(SEQ_LEN)
    right_location_num = 0
    zero_num = 0
    for step in range(len(input_data)):
        print(step,
              '------------------------------------------------------------>')
        x = input_data[step:(step + 1)]
        y = label_data[step:(step + 1)]
        max_y_index = 0
        # 求y的最大值下标
        for i in range(len(y[0])):
            if y[0][i] >= y[0][max_y_index]:
                max_y_index = i

        # if not (max_y_index >= 18 and max_y_index <= 22):  # 去掉低的情况
        #     total_num = total_num - 1
        #     continue

        data_sca[max_y_index] = data_sca[max_y_index] + 1
        x = np.array(x).reshape(1, SEQ_LEN, 1)
        y = np.array(y).reshape(1, SEQ_LEN, 1)
        x = torch.FloatTensor(x).cuda(0)
        y = torch.ByteTensor(y).cuda(0)
        prediction, _ = model(x, None)

        predict = torch.sigmoid(prediction) > 0.08
        max_predict_index = 0
        mm = 0
        for i in range(1, len(predict.view(-1))):
            if predict.view(-1)[i] > mm:
                max_predict_index = i
                mm = predict.view(-1)[i]

        if max_predict_index == 0:
            zero_num = zero_num + 1

        t = label_data[step:(step + 1)]
        # t=
        t = np.array(t[0]).tolist()
        pd = predict.view(-1).data.cpu().numpy()
        pd = np.array(pd).tolist()
        result = torch.eq(y, predict)
        res = result.view(-1).data.cpu().numpy()
        res = np.array(res).tolist()
        print('target:    ', t)
        print('predict:   ', pd)
        print('difference:', res)

        #
        # if (abs(max_y_index - max_predict_index) < 3):
        #     print('step: ', step)
        #     # sca_r[max_y_index] = sca_r[max_y_index] + 1
        #     relative_correct_num = relative_correct_num + 1

        # 在某个点上有物体完全预测正确
        # if t[0][max_y_index] == pd[max_y_index]:
        #     right_location_num = right_location_num+1

        # 在某个位置前后偏离两个位置
        if max_y_index >= 2 and max_y_index <= 62:
            if t[max_y_index] == pd[max_y_index] or t[max_y_index] == pd[max_y_index - 1] \
                    or t[max_y_index] == pd[max_y_index + 1] \
                    or t[max_y_index] == pd[max_y_index + 2] \
                    or t[max_y_index] == pd[max_y_index - 2] \
                    or t[max_y_index] == pd[max_y_index - 1]:
                print('relative right')
                right_location_num = right_location_num + 1
                sca_r[max_y_index] = sca_r[max_y_index] + 1
        else:
            if t[max_y_index] == pd[max_y_index]:
                right_location_num = right_location_num + 1
                sca_r[max_y_index] = sca_r[max_y_index] + 1

        accuracy = torch.sum(result) / torch.sum(torch.ones(y.shape))
        accuracy = accuracy.data.cpu().numpy()
        correct = torch.eq(torch.sum(~result), 0)
        print('accuracy: ', accuracy)
        print('correct: {}'.format(correct))
        if correct == 1:
            # right_index = int(max_y_index/10)
            sca[max_y_index] = sca[max_y_index] + 1
            correct_num = correct_num + 1
        print(
            '<------------------------------------------------------------------\n'
        )

    print(
        'total:',
        (step + 1),
        ' | correct_num:',
        correct_num,
        '| complete_correct_rate:',
        correct_num / total_num,
        # '| relative_correct_num : ', relative_correct_num, '| relative_correct_rate: ',
        # relative_correct_num / total_num,
        ' |right_location_rate: ',
        right_location_num / total_num,
        ' |zero_num:',
        zero_num,
        ' |zero_num_rate: ',
        zero_num / total_num)
    print('sca : ', sca)
    print('sca_r: ', sca_r)
    print('data_sca:', data_sca)

    right_distribute.distribute_cv(sca, data_sca, SEQ_LEN)
    right_distribute.distribute_cv(sca_r, data_sca, SEQ_LEN)
Ejemplo n.º 4
0
def model_test(model, input_data, label_data, is_debug=False, line=0.1):
    total_num = len(input_data)

    correct_num = 0
    st2_num = 0
    st3_num = 0
    total_num = len(input_data)
    st1 = np.zeros(64)
    st2 = np.zeros(64)
    st3 = np.zeros(64)
    data_sca = np.zeros(64)

    zero_num = 0
    for step in range(len(input_data)):
        if is_debug:
            print(
                '\n<----------------------------------------------------------',
                step)
        x = input_data[step:(step + 1)]
        y = label_data[step:(step + 1)]
        max_y_index = 0
        # 求y的最大值下标
        for i in range(len(y[0])):
            if y[0][i] >= y[0][max_y_index]:
                max_y_index = i

        # if not (max_y_index >= 18 and max_y_index <= 22):  # 去掉低的情况
        #     total_num = total_num - 1
        #     continue

        data_sca[max_y_index] = data_sca[max_y_index] + 1
        x = np.array(x).reshape(1, SEQ_LEN, 1)
        y = np.array(y).reshape(1, SEQ_LEN, 1)
        x = torch.FloatTensor(x).cuda(0)
        y = torch.ByteTensor(y).cuda(0)
        prediction, _ = model(x, None)

        predict = torch.sigmoid(prediction) > line
        max_predict_index = 0
        mm = 0
        for i in range(1, len(predict.view(-1))):
            if predict.view(-1)[i] > mm:
                max_predict_index = i
                mm = predict.view(-1)[i]

        if max_predict_index == 0:
            zero_num = zero_num + 1

        t = label_data[step:(step + 1)]
        # t=
        t = np.array(t[0]).tolist()
        pd = predict.view(-1).data.cpu().numpy()
        pd = np.array(pd).tolist()
        result = torch.eq(y, predict)
        res = result.view(-1).data.cpu().numpy()
        res = np.array(res).tolist()
        if is_debug:
            print('target:    ', t)
            print('predict:   ', pd)
            print('difference:', res)

        # 在某个位置前后偏离两个位置
        if standard_define.is_satisfied_standard2(pd, max_y_index):
            st2_num = st2_num + 1
            st2[max_y_index] = st2[max_y_index] + 1

        if standard_define.is_satisfied_standard3(pd, max_y_index):
            st3_num = st3_num + 1
            st3[max_y_index] = st3[max_y_index] + 1

        accuracy = torch.sum(result) / torch.sum(torch.ones(y.shape))
        accuracy = accuracy.data.cpu().numpy()
        correct = torch.eq(torch.sum(~result), 0)
        if is_debug:
            print('accuracy: ', accuracy)
            print('correct: {}'.format(correct))
        if correct == 1:
            # right_index = int(max_y_index/10)
            st1[max_y_index] = st1[max_y_index] + 1
            correct_num = correct_num + 1  # 标准1,完全匹配
        if is_debug:
            print(
                '-------------------------------------------------------------->\n'
            )

    if is_debug:
        print('total:', (step + 1), ' | correct_num:', correct_num,
              '| complete_correct_rate:', correct_num / total_num,
              '| st2_num: ', st2_num, ' |st2_rate: ', st2_num / total_num,
              '| st3_num: ', st3_num, ' |st3_rate: ', st3_num / total_num)
        print('st1 : ', st1)
        print('data_sca : ', data_sca)

        right_distribute.distribute_cv(st1, data_sca, 36, 'st1完全正确预测分布')
        right_distribute.distribute_cv(st2, data_sca, 36, 'st2相对预测正确率')
        right_distribute.distribute_cv(st3, data_sca, 36, 'st3相对预测正确率')

    return correct_num / total_num, st2_num / total_num, st3_num / total_num
Ejemplo n.º 5
0
def model_test(model_path):
    model = torch.load(model_path)
    # input_data, label_data = radar_data.load_pg_test_data()
    _, _1, input_data, label_data = radar_data.load_pg_data_by_range(15, 30)

    # L = len(input_data)

    correct_num = 0
    relative_correct_num = 0
    total_num = len(input_data)
    sca = np.zeros(64)
    sca_r = np.zeros(64)
    data_sca = np.zeros(64)
    for step in range(len(input_data)):
        print('\n<----------------------------------------------------------',
              step)
        x = input_data[step:(step + 1)]
        y = label_data[step:(step + 1)]
        max_y_index = 0
        # 求y的最大值下标
        for i in range(len(y[0])):
            if y[0][i] >= y[0][max_y_index]:
                max_y_index = i

        # if max_y_index >35:
        #     print('error: ', y)
        #     break
        # if max_y_index > 30:
        #     total_num = total_num - 1
        #     continue

        # data_index = int(max_y_index/10)
        data_sca[max_y_index] = data_sca[max_y_index] + 1

        data_sca[max_y_index] = data_sca[max_y_index] + 1
        x = np.array(x).reshape(1, 64, 1)
        # y = np.array(y).reshape(1, 64, 1)
        x = torch.FloatTensor(x).cuda(0)
        y = torch.ByteTensor(y).cuda(0)

        prediction, _ = model(x, None)
        _, max = torch.max(prediction.data, 1)
        index = 0
        mm = prediction[0][0]
        for i in range(1, len(prediction[0])):
            if prediction[0][i] > mm:
                index = i
                mm = prediction[0][i]
        predict = [j - j for j in range(0, 64)]
        predict[index] = 1
        predict = [predict]
        predict = torch.ByteTensor(predict).cuda(0)
        # predict = torch.sigmoid(prediction) > 0.5

        # predict = prediction
        print('y:      ', y.data.cpu().numpy().tolist())
        print('predict:', predict.data.cpu().numpy().tolist())
        print(torch.eq(y, predict))

        max_predict_index = torch.max(predict, 1)[1].data.cpu().numpy()[0]

        if (abs(max_y_index - max_predict_index) < 3):
            sca_r[max_y_index] = sca_r[max_y_index] + 1
            relative_correct_num = relative_correct_num + 1

        result = torch.eq(y, predict)
        accuracy = torch.sum(result) / torch.sum(torch.ones(y.shape))
        accuracy = accuracy.data.cpu().numpy()
        correct = torch.eq(torch.sum(~result), 0)
        print('accuracy: ', accuracy)
        print('correct: {}'.format(correct))
        if correct == 1:
            # right_index = int(max_y_index/10)
            sca[max_y_index] = sca[max_y_index] + 1
            correct_num = correct_num + 1
        print(
            '-------------------------------------------------------------->\n'
        )

    print('total:', (step + 1), ' | correct_num:', correct_num,
          '| complete_correct_rate:', correct_num / total_num,
          '| relative_correct_num : ', relative_correct_num,
          '| relative_correct_rate: ', relative_correct_num / total_num)
    print('sca : ', sca)
    print('data_sca : ', data_sca)

    right_distribute.distribute_cv(sca, data_sca, 64)
    right_distribute.distribute_cv(sca_r, data_sca, 64)
Ejemplo n.º 6
0
def model_test(model_path):
    model = torch.load(model_path)
    # input_data, label_data = radar_data.load_pg_test_data()
    # _, _1, input_data, label_data = radar_data.load_pg_data_by_range(0, 64)
    _, _1, input_data, label_data = radar_data.rerange_road_data()
    # L = len(input_data)
    # train_data_input, train_data_label = radar_data.load_pg_val_data()
    correct_num = 0
    relative_correct_num = 0
    total_num = len(input_data)
    sca = np.zeros(64)
    sca_r = np.zeros(64)
    data_sca = np.zeros(64)
    right_location_num = 0
    for step in range(len(input_data)):
        print('\n<----------------------------------------------------------', step)
        x = input_data[step:(step + 1)]
        y = label_data[step:(step + 1)]
        max_y_index = 0
        # 求y的最大值下标
        for i in range(len(y[0])):
            if y[0][i] >= y[0][max_y_index]:
                max_y_index = i

        # if max_y_index >35:
        #     print('error: ', y)
        #     break
        # if max_y_index > 30:
        #     total_num = total_num - 1
        #     continue

        # data_index = int(max_y_index/10)
        data_sca[max_y_index] = data_sca[max_y_index] + 1

        x = np.array(x).reshape(1, 1, 64)
        y = np.array(y).reshape(1, 1, 64)
        x = torch.FloatTensor(x).cuda(0)
        y = torch.ByteTensor(y).cuda(0)
        prediction = model(x)
        _, max = torch.max(prediction.data, 1)
        index = 0
        # mm = prediction[0][0]
        # for i in range(1, len(prediction[0])):
        #     if prediction[0][i] > mm:
        #         index = i
        #         mm = prediction[0][i]
        # predict = [j - j for j in range(0, 64)]
        # predict[index] = 1
        # predict = [predict]
        # predict = torch.ByteTensor(predict).cuda(0)
        predict = torch.sigmoid(prediction) > 0.15

        # predict = prediction
        # print('y:     ', y)
        # print('predict:', predict)
        # print(torch.eq(y, predict))

        t = label_data[step:(step + 1)]
        # t=
        t = np.array(t[0]).tolist()
        pd = predict.view(-1).data.cpu().numpy()
        pd = np.array(pd).tolist()
        result = torch.eq(y, predict)
        res = result.view(-1).data.cpu().numpy()
        res = np.array(res).tolist()
        print('target:    ', t)
        print('predict:   ', pd)
        print('difference:', res)

        max_predict_index = torch.max(predict, 1)[1].data.cpu().numpy()[0]

        if (abs(max_y_index - max_predict_index) < 2):
            # sca_r[max_y_index] = sca_r[max_y_index] + 1
            relative_correct_num = relative_correct_num + 1

        if max_y_index >= 2 and max_y_index <= 62:
            if t[max_y_index] == pd[max_y_index] or t[max_y_index] == pd[max_y_index - 1] \
                    or t[max_y_index] == pd[max_y_index + 1] \
                    or t[max_y_index] == pd[max_y_index - 1] :
                    # or t[max_y_index] == pd[max_y_index + 2] \
                    # or t[max_y_index] == pd[max_y_index - 2]:
                print('relative right')
                right_location_num = right_location_num + 1
                sca_r[max_y_index] = sca_r[max_y_index] + 1
        else:
            if t[max_y_index] == pd[max_y_index]:
                right_location_num = right_location_num + 1
                sca_r[max_y_index] = sca_r[max_y_index] + 1

        result = torch.eq(y, predict)
        accuracy = torch.sum(result) / torch.sum(torch.ones(y.shape))
        accuracy = accuracy.data.cpu().numpy()
        correct = torch.eq(torch.sum(~result), 0)
        print('accuracy: ', accuracy)
        print('correct: {}'.format(correct))
        if correct == 1:
            # right_index = int(max_y_index/10)
            sca[max_y_index] = sca[max_y_index] + 1
            correct_num = correct_num + 1
        print('-------------------------------------------------------------->\n')

    print('total:', (step + 1), ' | correct_num:', correct_num, '| complete_correct_rate:', correct_num / total_num,
          # '| relative_correct_num : ', relative_correct_num, '| relative_correct_rate: ',
          # relative_correct_num / total_num,
          ' |right_location_rate: ', right_location_num / total_num)
    print('sca : ', sca)
    print('data_sca : ', data_sca)

    right_distribute.distribute_cv(sca, data_sca, 64)
    right_distribute.distribute_cv(sca_r, data_sca, 64)
Ejemplo n.º 7
0
def model_test(model_path):
    model = torch.load(model_path)
    # input_data, label_data = radar_data.load_pg_test_data()
    _, _1, input_data, label_data = radar_data.load_pg_data_by_range(0, 64)

    # input_data, label_data = radar_data.load_val_data(
    #     'D:\home\zeewei\projects\\77GRadar\data\\all\\all_val_data.npy')
    # L = len(input_data)

    correct_num = 0
    relative_correct_num = 0
    total_num = len(input_data)
    sca = np.zeros(64)
    sca_r = np.zeros(64)
    data_sca = np.zeros(64)
    right_location_num = 0
    zero_num = 0
    for step in range(len(input_data)):
        print('\n<----------------------------------------------------------', step)
        x = input_data[step:(step + 1)]
        y = label_data[step:(step + 1)]
        max_y_index = 0
        # 求y的最大值下标
        for i in range(len(y[0])):
            if y[0][i] >= y[0][max_y_index]:
                max_y_index = i

        data_sca[max_y_index] = data_sca[max_y_index] + 1

        x = np.array(x).reshape(1, 1, 64)
        y = np.array(y).reshape(1, 1, 64)
        x = torch.FloatTensor(x).cuda(0)
        y = torch.ByteTensor(y).cuda(0)
        prediction = model(x)
        _, max = torch.max(prediction.data, 1)

        predict = torch.sigmoid(prediction) > 0.015625

        max_predict_index = 0
        mm = 0
        for i in range(1, len(predict.view(-1))):
            if predict.view(-1)[i] > mm:
                max_predict_index = i
                mm = predict.view(-1)[i]

        if max_predict_index == 0:
            zero_num = zero_num + 1

        t = label_data[step:(step + 1)]
        # t=
        t = np.array(t[0]).tolist()
        tt = []
        for item in t:
            if item == 0:
                tt.append(0)
            else:
                tt.append(1)
        t = tt
        pd = predict.view(-1).data.cpu().numpy()
        pd = np.array(pd).tolist()
        result = torch.eq(y, predict)
        res = result.view(-1).data.cpu().numpy()
        res = np.array(res).tolist()
        print('target:    ', t)
        print('predict:   ', pd)
        print('difference:', res)

        max_predict_index = torch.max(predict, 1)[1].data.cpu().numpy()[0]

        # 在某个位置前后偏离两个位置
        if max_y_index >= 2 and max_y_index <= 62:
            if t[max_y_index] == pd[max_y_index] or t[max_y_index] == pd[max_y_index - 1] \
                    or t[max_y_index] == pd[max_y_index + 1] \
                    or t[max_y_index] == pd[max_y_index - 1]:
                # or t[max_y_index] == pd[max_y_index + 2] \
                # or t[max_y_index] == pd[max_y_index - 2] \

                print('relative right')
                right_location_num = right_location_num + 1
                sca_r[max_y_index] = sca_r[max_y_index] + 1
        else:
            if t[max_y_index] == pd[max_y_index]:
                right_location_num = right_location_num + 1
                sca_r[max_y_index] = sca_r[max_y_index] + 1

        result = torch.eq(y, predict)
        accuracy = torch.sum(result) / torch.sum(torch.ones(y.shape))
        accuracy = accuracy.data.cpu().numpy()
        correct = torch.eq(torch.sum(~result), 0)
        print('accuracy: ', accuracy)
        print('correct: {}'.format(correct))
        if correct == 1:
            # right_index = int(max_y_index/10)
            sca[max_y_index] = sca[max_y_index] + 1
            correct_num = correct_num + 1
        print('-------------------------------------------------------------->\n')

    print('total:', (step + 1),
          ' \n| correct_num:', correct_num,
          ' \n| complete_correct_rate:', correct_num / total_num,
          ' \n|right_location_rate: ', right_location_num / total_num,
          ' \n|zero_num:', zero_num,
          ' \n|zero_num_rate: ', zero_num / total_num)
    print('sca : ', sca)
    print('sca_r: ', sca_r)
    print('data_sca:', data_sca)
    right_distribute.distribute_cv(sca, data_sca, 64)
    right_distribute.distribute_cv(sca_r, data_sca, 64)