Пример #1
0
def get_s(name):

    sight = fc.get_car_sight(name)
    wight = len(sight[0])
    hight = len(sight)
    ti = fc.get_ti(name)
    mid = ti['mid']

    while len(mid) < 5:
        mid.append(mid[len(mid) - 1])
    mid = np.array([mid[i * (len(mid) - 1) // 6] for i in range(5)])
    mid = mid - np.array([wight / 2, 0])
    mid = np.array([0, hight]) - mid
    s = np.reshape(mid, 10)
    s = np.concatenate([s, np.array([fc.get_velocity(name)])], 0)
    return s
Пример #2
0
times = 1
fc.start()
while times:

    start_time = fc.get_time()
    normal_working = 0
    s, a, r, s_ = [], [], [], []

    if times % 10 == 1:
        var += np.array([np.pi / 3, 100]) / 5

    s += [get_s('0')]

    while abs((fc.get_time() - start_time - normal_working) *
              fc.get_velocity('0') / 100000) < 0.3 and abs(
                  normal_working * fc.get_velocity('0') / 100000) < 60:
        p = ddpg.predict(s[-1])
        a += [p[0]]
        if ddpg.frame < ddpg.REPLAY_CAPACITY / 8:
            a[-1] = np.array([0., 100.])
        a[-1] = np.random.normal(
            a[-1] * np.random.uniform(max(1 - np.sqrt(var[0]), 0), 2), var, 2)

        fc.ctrl('0', *(a[-1]))
        run_time = fc.get_time()
        while fc.get_time() - run_time < FRAME_SPACING:
            if ddpg.frame > ddpg.REPLAY_CAPACITY / 8:
                ddpg.fit()
                var *= 0.9999
            else:
Пример #3
0
fc.set_time_speed(0)

ddpg = DDPG.DDPG(11,2,np.array([np.pi/3, 256]))
var=np.array([np.pi/3,30])

times = 1
fc.start()
while times:

    start_time = fc.get_time()
    normal_working = 0
    s,a,r,s_ = [],[],[],[]
    
    s += [get_s('0')]

    while  abs((fc.get_time()-start_time-normal_working)*fc.get_velocity('0')/100000) < 0.3 and abs(normal_working*fc.get_velocity('0')/100000) < 60:
        p=ddpg.predict(s[-1])
        a += [p[0][0]]
        a[-1] += np.random.normal(a[-1]*np.random.uniform(max(1-np.sqrt(var[0]),0),2), var,2)

        fc.ctrl('0',*(a[-1]+np.array([0,192])))
        run_time = fc.get_time()
        while fc.get_time()-run_time < FRAME_SPACING:
            if ddpg.frame>ddpg.REPLAY_CAPACITY/8:
                ddpg.fit()
                var*=0.9999
            else:
                fc.sleep(1)

        r += [get_r('0')]
        s_ += [get_s('0')]
Пример #4
0
            else:
                fc.sleep(1)

        if ddpg.frame > 500:
            var *= .999
            print('var', var)

        r += [get_r('0') - np.square(*a[-1] * 2)]
        s_ += [get_s('0')]
        if r[-1] <= -1000:
            break_count += 1
        else:
            break_count = 0

        ddpg.record(s[pointer], a[pointer], r[-1] / 100, s_[-1])
        pointer += 1

        s += [s_[-1]]

        print('a', *a[-1], '\t', 'r', r[-1], '\t', 'frame', ddpg.frame)
        print('v', fc.get_velocity('0'), '\n')

    fc.set_car('0', (430 + np.random.normal(0, 5), 300), np.pi / 2, 0.)
    times += 1

    if times % 20 == 0:
        fc.map_clear()
    # fit_time = time.time()
    # while time.time()-fit_time < 5:
    #     ddpg.fit()
Пример #5
0
degree = 0
velocity = 100

times = 1
fc.set_time_speed(1)
fc.start()
reset_time = fc.get_time()
while times:

    sight = cv2.resize(np.array(fc.get_car_sight("0")), (16, 16))
    sight = np.reshape(sight, [16, 16, 1])
    out = model.predict({
        input_map: [sight],
        input_degree: [np.array([degree])],
        input_velocity: [np.array([fc.get_velocity('0')])]
    })

    degree = out[0][0] * np.pi / 3
    #   velocity=(out[0][1]+1)*200
    velocity = 100

    fc.ctrl('0', degree, velocity)

    print(out)
    print(len(train_y))

    train_sight += [sight]
    train_degree += [np.array([degree])]
    train_velocity += [np.array([velocity])]
Пример #6
0
        left.append([0, 0])
    if len(right) == 0:
        right.append([wight - 1, hight - 1])
    while len(right) < 5:
        right.append(right[len(right) - 1])
    while len(left) < 5:
        left.append(left[len(left) - 1])

    right = np.array([right[i * (len(right) - 1) // 5] for i in range(5)])
    left = np.array([left[i * (len(left) - 1) // 5] for i in range(5)])

    train_left += [left]
    train_right += [right]
    train_state += [
        np.array([degree / np.pi / 2 * 3 + 0.5,
                  fc.get_velocity('0') / 200])
    ]

    out = model_ctrl.predict({
        input_left: [train_left[-1]],
        input_right: [train_right[-1]],
        input_state: [train_state[-1]]
    })

    if not times % 20:
        mid = ti['mid']
        out[0][0] = (mid[0][0] -
                     (wight - 1) / 2) * 0.04 + (mid[len(mid) // 3][0] -
                                                (wight - 1) / 2) * 0.04
        out[0][0] = out[0][0] / 2. / np.pi * 3. + 0.5
        out[0][1] = 300 - fc.get_velocity('0') * 2