Example #1
0
def calculate_ESN(name, rand_seed, nReservoir, spectralRadius, future, futureTotal):
    data = open(name + ".txt").read().split()
    data = np.array(data).astype("float64")
    n_resevoir = 500
    sparsity = 0.2
    rand_seed = 23
    spectral_radius = 1.2
    noise = 0.0005
    future = 1
    futureTotal = 7

    esn = ESN(
        n_inputs=1,
        n_outputs=1,
        n_reservoir=nReservoir,
        sparsity=sparsity,
        random_state=rand_seed,
        spectral_radius=spectralRadius,
        noise=noise,
    )

    trainlen = data.__len__() - futureTotal
    pred_tot = np.zeros(futureTotal)

    for i in range(0, futureTotal, future):
        pred_training = esn.fit(np.ones(trainlen), data[i : trainlen + i])
        prediction = esn.predict(np.ones(future))
        pred_tot[i : i + future] = prediction[:, 0]
    return pred_tot
Example #2
0
def pso_esn_parameters_for_elasticnet(x):
    ic_s =x[0]
    ic_e =x[1]
    is_s = x[2]
    is_e = x[3]
    teacher_scaling = x[4]
    teacher_shift = x[5]
    alpha =x[6]
    l1_ratio=x[7]

     
    esn = ESN(n_inputs = 2,
             n_outputs = 1,
             n_reservoir = n_reservoir,
             spectral_radius = spectral_radius, 
             sparsity = sparsity,
             noise = noise,
             input_shift = [is_s,is_e],#[0,0]
             input_scaling =[ic_s,ic_e],# [0.01, 3]
             teacher_scaling = teacher_scaling,#1.12,
             teacher_shift = teacher_shift,#-0.7,
             out_activation = np.tanh,
             inverse_out_activation = np.arctanh,
             random_state = rng,
             silent = False)
    esn.alpha = alpha
    esn.l1_ratio = l1_ratio
    internal_states,transient = esn.train_reservior(train_ctrl,train_output)
    pred_train = esn.train_readout_with_elasticnet(internal_states,train_output,transient)
    pred_test = esn.predict(test_ctrl)
    test_error_rate= np.sqrt(np.mean((pred_test - test_output)**2))
    #get function name as title
    title = inspect.stack()[0][3]
    print "#### {} ## train_error:{},test_error:{}".format(title,esn.train_error_rate,test_error_rate)
    return test_error_rate
Example #3
0
    def test_freqgen(self):
        rng = np.random.RandomState(42)
        def frequency_generator(N,min_period,max_period,n_changepoints):
            """returns a random step function + a sine wave signal that
               changes its frequency at each such step."""
            # vector of random indices < N, padded with 0 and N at the ends:
            changepoints = np.insert(np.sort(rng.randint(0,N,n_changepoints)),[0,n_changepoints],[0,N])
            # list of interval boundaries between which the control sequence should be constant:
            const_intervals = zip(changepoints,np.roll(changepoints,-1))[:-1]
            # populate a control sequence
            frequency_control = np.zeros((N,1))
            for (t0,t1) in const_intervals:
                frequency_control[t0:t1] = rng.rand()
            periods = frequency_control * (max_period - min_period) + max_period

            # run time through a sine, while changing the period length
            frequency_output = np.zeros((N,1))
            z = 0
            for i in range(N):
                z = z + 2 * np.pi / periods[i]
                frequency_output[i] = (np.sin(z) + 1)/2
            return np.hstack([np.ones((N,1)),1-frequency_control]),frequency_output

        N = 15000
        min_period = 2
        max_period = 10
        n_changepoints = N/200
        frequency_control,frequency_output = frequency_generator(N,min_period,max_period,n_changepoints)

        traintest_cutoff = np.ceil(0.7*N)
        train_ctrl,train_output = frequency_control[:traintest_cutoff],frequency_output[:traintest_cutoff]
        test_ctrl, test_output  = frequency_control[traintest_cutoff:],frequency_output[traintest_cutoff:]

        esn = ESN(n_inputs = 2,
                  n_outputs = 1,
                  n_reservoir = 200,
                  spectral_radius = 0.25,
                  sparsity = 0.95,
                  noise = 0.001,
                  input_shift = [0,0],
                  input_scaling = [0.01, 3],
                  teacher_scaling = 1.12,
                  teacher_shift = -0.7,
                  out_activation = np.tanh,
                  inverse_out_activation = np.arctanh,
                  random_state = rng,
                  silent = True)

        pred_train = esn.fit(train_ctrl,train_output)
        #print "test error:"
        pred_test = esn.predict(test_ctrl)
        error = np.sqrt(np.mean((pred_test - test_output)**2))
        self.assertAlmostEqual(error,0.39037112433756577)
Example #4
0
 def test_IODimensions(self):
     """try different combinations of input & output dimensionalities & teacher forcing"""
     tasks = [(1,1,100,True),(10,1,100,True),(1,10,100,True),(10,10,100,True),
              (1,1,100,False),(10,1,100,False),(1,10,100,False),(10,10,100,False)]
     for t in tasks:
         N_in ,N_out, N_samples, tf = t
         X = np.random.randn(N_samples,N_in)  if N_in > 1 else np.random.randn(N_samples)
         y = np.random.randn(N_samples,N_out) if N_out > 1 else np.random.randn(N_samples)
         Xp = np.random.randn(N_samples,N_in) if N_in > 1 else np.random.randn(N_samples)
         esn = ESN(N_in,N_out,teacher_forcing=tf)
         prediction_tr = esn.fit(X,y)
         prediction_t = esn.predict(Xp)
         self.assertEqual(prediction_tr.shape,(N_samples,N_out))
         self.assertEqual(prediction_t.shape,(N_samples,N_out))
Example #5
0
 def test_IODimensions(self):
     """try different combinations of input & output dimensionalities & teacher forcing"""
     tasks = [(1, 1, 100, True), (10, 1, 100, True), (1, 10, 100, True), (10, 10, 100, True),
              (1, 1, 100, False), (10, 1, 100, False), (1, 10, 100, False), (10, 10, 100, False)]
     for t in tasks:
         N_in, N_out, N_samples, tf = t
         X = np.random.randn(
             N_samples, N_in) if N_in > 1 else np.random.randn(N_samples)
         y = np.random.randn(
             N_samples, N_out) if N_out > 1 else np.random.randn(N_samples)
         Xp = np.random.randn(
             N_samples, N_in) if N_in > 1 else np.random.randn(N_samples)
         esn = ESN(N_in, N_out, teacher_forcing=tf)
         prediction_tr = esn.fit(X, y)
         prediction_t = esn.predict(Xp)
         self.assertEqual(prediction_tr.shape, (N_samples, N_out))
         self.assertEqual(prediction_t.shape, (N_samples, N_out))
Example #6
0
    def test_mackey(self):
        try:
            data = np.load('mackey_glass_t17.npy')
        except IOError:
            self.skipTest("missing data")

        esn = ESN(n_inputs = 1,
                  n_outputs = 1,
                  n_reservoir = 500,
                  spectral_radius = 1.5,
                  random_state=42)

        trainlen = 2000
        future = 2000
        esn.fit(np.ones(trainlen),data[:trainlen])
        prediction = esn.predict(np.ones(future))
        error = np.sqrt(np.mean((prediction.flatten() - data[trainlen:trainlen+future])**2))
        self.assertAlmostEqual(error,0.1396039098653574)
Example #7
0
    def test_mackey(self):
        try:
            data = np.load('mackey_glass_t17.npy')
        except IOError:
            self.skipTest("missing data")

        esn = ESN(n_inputs=1,
                  n_outputs=1,
                  n_reservoir=500,
                  spectral_radius=1.5,
                  random_state=42)

        trainlen = 2000
        future = 2000
        esn.fit(np.ones(trainlen), data[:trainlen])
        prediction = esn.predict(np.ones(future))
        error = np.sqrt(
            np.mean((prediction.flatten() - data[trainlen:trainlen + future])**2))
        self.assertAlmostEqual(error, 0.1396039098653574)
Example #8
0
def pso_esn_parameters_for_scad(x):
    # 0: tao, 1:c0, 2:IC_s,3:IC_e 4:IS_s,5:IS_e, ,6:teacher sacling,7:teacher shift
    # 0:IC_s,1:IC_e, 2:IS_s,3:IS_e, 4:teacher sacling,5:teacher shift,6: tao, 7:c0,
    ic_s =x[0]
    ic_e =x[1]
    is_s = x[2]
    is_e = x[3]
    teacher_scaling = x[4]
    teacher_shift = x[5]
    tao = x[6]
    c0 =  x[7]
     
    esn = ESN(n_inputs = 2,
             n_outputs = 1,
             n_reservoir = n_reservoir,
             spectral_radius = spectral_radius, 
             sparsity = sparsity,
             noise = noise,
             input_shift = [is_s,is_e],#[0,0]
             input_scaling =[ic_s,ic_e],# [0.01, 3]
             teacher_scaling = teacher_scaling,#1.12,
             teacher_shift = teacher_shift,#-0.7,
             out_activation = np.tanh,
             inverse_out_activation = np.arctanh,
             random_state = rng,
             silent = False)
    esn.penal_tao =tao
    esn.penal_c0 = c0
    internal_states,transient = esn.train_reservior(train_ctrl,train_output)
    pred_train = esn.train_readout_with_scad(internal_states,train_output,transient)
    pred_test = esn.predict(test_ctrl)
    #test_error_rate= np.sqrt(np.mean((pred_test - test_output)**2))
    test_error_rate= np.sqrt((pred_test - test_output)**2)
    #get function name as title
    title = inspect.stack()[0][3]
    print "#### {} ## train_error:{},test_error:{}".format(title,esn.train_error_rate,test_error_rate)
    return test_error_rate
    这里画一个原始测试序列的图和一个test_output的图。
def mackey(reservoir_size, spectral_radius, train_len, future):

    # Load in mackey-glass numpy array
    data = np.load('mackey_glass_t17.npy'
                   )  #  http://minds.jacobs-university.de/mantas/code

    #Initialize ESN
    esn = ESN(n_inputs=1,
              n_outputs=1,
              n_reservoir=reservoir_size,
              spectral_radius=spectral_radius,
              random_state=42)

    # Fit the model
    pred_training = esn.fit(np.ones(train_len), data[:train_len])

    # Predict and find the error
    prediction = esn.predict(np.ones(future))
    error = np.sqrt(
        np.mean(
            (prediction.flatten() - data[train_len:train_len + future])**2))

    return error, prediction, reservoir_size, spectral_radius, train_len, future
def henon(reservoir_size, spectral_radius, train_len, future):

    # Load in mackey-glass numpy array
    data_full = hn.henon()
    data = data_full[0]

    #Initialize ESN
    esn = ESN(n_inputs=1,
              n_outputs=1,
              n_reservoir=reservoir_size,
              spectral_radius=spectral_radius,
              random_state=42)

    # Fit the model
    pred_training = esn.fit(np.ones(train_len), data[:train_len])

    # Predict and find the error
    prediction = esn.predict(np.ones(future))
    error = np.sqrt(
        np.mean(
            (prediction.flatten() - data[train_len:train_len + future])**2))

    return error, prediction, reservoir_size, spectral_radius, train_len, future
Example #11
0
    def test_inputshift(self):
        """input shift factors of different formats should be correctly interpreted or rejected"""
        esn = ESN(N_in,N_out,input_shift=1)
        self.assertTrue(np.all(1+self.X == esn._scale_inputs(self.X)))
        esn.fit(self.X,self.y)
        esn.predict(self.Xp)

        esn = ESN(N_in,N_out,input_shift=[1]*N_in)
        self.assertTrue(np.all(1+self.X == esn._scale_inputs(self.X)))
        esn.fit(self.X,self.y)
        esn.predict(self.Xp)

        esn = ESN(N_in,N_out,input_shift=np.array([1]*N_in))
        self.assertTrue(np.all(1+self.X == esn._scale_inputs(self.X)))
        esn.fit(self.X,self.y)
        esn.predict(self.Xp)

        with self.assertRaises(ValueError):
            esn = ESN(N_in,N_out,input_shift=[1]*(N_in+1))

        with self.assertRaises(ValueError):
            esn = ESN(N_in,N_out,input_shift=np.array([[1]*N_in]))
Example #12
0
    def test_inputshift(self):
        """input shift factors of different formats should be correctly interpreted or rejected"""
        esn = ESN(N_in, N_out, input_shift=1)
        self.assertTrue(np.all(1 + self.X == esn._scale_inputs(self.X)))
        esn.fit(self.X, self.y)
        esn.predict(self.Xp)

        esn = ESN(N_in, N_out, input_shift=[1] * N_in)
        self.assertTrue(np.all(1 + self.X == esn._scale_inputs(self.X)))
        esn.fit(self.X, self.y)
        esn.predict(self.Xp)

        esn = ESN(N_in, N_out, input_shift=np.array([1] * N_in))
        self.assertTrue(np.all(1 + self.X == esn._scale_inputs(self.X)))
        esn.fit(self.X, self.y)
        esn.predict(self.Xp)

        with self.assertRaises(ValueError):
            esn = ESN(N_in, N_out, input_shift=[1] * (N_in + 1))

        with self.assertRaises(ValueError):
            esn = ESN(N_in, N_out, input_shift=np.array([[1] * N_in]))
Example #13
0
def ESN_train(data):
    #print(data)
    total_col = data.shape[1]

    opt_ang_col = data[:, total_col - 1]
    #print(opt_ang_col)

    max_angle = max(opt_ang_col)
    #print(max_angle)
    opt_ang_col = opt_ang_col / max_angle / 2

    #print(opt_ang_col)

    opt_ang_col = np.transpose(opt_ang_col)

    #print(opt_ang_col)

    N = flytera_cfg.sim_tick

    rng = np.random.RandomState(42)
    traintest_cutoff = int(np.ceil(0.66 * N))
    train_data, train_data_angle = data[:
                                        traintest_cutoff], opt_ang_col[:
                                                                       traintest_cutoff]
    test_data, test_data_angle = data[traintest_cutoff:], opt_ang_col[
        traintest_cutoff:]
    #print('TEST DAtA ANGLE', test_data_angle)
    rows_zeros_ip_shift = np.zeros(total_col)
    #print('zeros', zeros)
    rows_ones_ip_scale = np.ones(total_col)

    esn = ESN(
        n_inputs=total_col,
        n_outputs=1,
        n_reservoir=50,
        spectral_radius=0.25,
        sparsity=0.25,
        noise=0.001,
        input_shift=rows_zeros_ip_shift,
        input_scaling=rows_ones_ip_scale,
        #input_scaling=[1, 1],
        teacher_scaling=0.4,
        #teacher_scaling=1,
        teacher_shift=0,
        #teacher_shift=0,
        # teacher_scaling = None,
        # teacher_shift = None,
        out_activation=np.tanh,
        inverse_out_activation=np.arctanh,
        random_state=rng,
        silent=False)

    print('n_inputs=', esn.n_inputs)
    print('n_outputs=', esn.n_outputs)
    print('n_reservoir=', esn.n_reservoir)
    print('spectral radius=', esn.spectral_radius)
    print('sparsity=', esn.sparsity)
    print('noise=', esn.noise)
    print('input_shift=', esn.input_shift)
    print('input_scaling=', esn.input_scaling)
    print('teacher_forcing=', esn.teacher_forcing)
    # print ('feedback_scaling=' , esn1.feedback_scaling)
    print('teacher_scaling=', esn.teacher_scaling)
    print('teacher_shift=', esn.teacher_shift)
    print('out_activation=', esn.out_activation)
    print('inverse_out=', esn.inverse_out_activation)
    print('random_state=', esn.random_state)
    print('silent=', esn.silent)

    pred_train = esn.fit(train_data, train_data_angle)
    #print(pred_train)
    pred_test = esn.predict(test_data)
    #print('PREDICTED TEST', pred_test)
    pred_max_angle = max(pred_test) * 2 * max_angle
    return_angles = np.ceil(pred_test * 2 * max_angle)
    pred_max_angle = int(np.ceil(pred_max_angle))
    #print(pred_max_angle)
    #exit()
    pp.figure(1)
    font = {'family': 'sans', 'size': 14}
    pp.rc('font', **font)
    pp.xlim(0, 100)
    pp.ylim(0, 20)
    pp.xlabel('Network Run Time (slot)')
    pp.ylabel('Directivity Angle (degree)')
    #print()
    #print()
    a = (test_data_angle * 2 * max_angle)[0]
    b = (pred_test * 2 * max_angle)[0]
    #print(a)
    #print(b)
    acc = 100 - ((a - b) / a) * 100
    #print(acc)
    #exit()
    #print(test_data_angle*2*max_angle)
    #print(pred_test*2*max_angle)
    before = sum(test_data_angle * 2 * max_angle)
    after = sum(pred_test * 2 * max_angle)
    #print(before)
    #print(after)
    error = (abs(after - before) / after) * 100
    #print(accuracy1)
    #accuracy2 = (after/before)*100
    #print(accuracy2)

    pp.plot(range(len(test_data_angle)),
            test_data_angle * 2 * max_angle,
            c='r',
            marker='o',
            label='Optimal Directivity Angle')
    pp.plot(range(len(test_data_angle)),
            pred_test * 2 * max_angle,
            c='k',
            linestyle='--',
            label='Predicted Directivity Angle')
    pp.legend()
    pp.grid(True)
    pp.show()
    exit()
    list_angles = [(pred_max_angle), (pred_max_angle) * 2,
                   (pred_max_angle) * 4, (pred_max_angle) * 6,
                   (pred_max_angle) * 8]
    #print(list_angles)

    return return_angles
Example #14
0
def esn2_training(data, index2):
    #print('a',data)
    N = np.size(data, 0)
    #print(N)
    rng = np.random.RandomState(42)
    traintest_cutoff = int(np.ceil(0.8 * N))
    data_index = data[:, 3 * netcfg.num_lte_bs_mobile + 1]
    #print(np.transpose(np.array([data_index])))
    #print('a',data_index)
    data_index_max = max(data_index)
    data_index = data_index / data_index_max / 2
    data_index = np.transpose(np.array([data_index]))
    #print(data_index)
    train_data, train_data_index = data[:
                                        traintest_cutoff], data_index[:
                                                                      traintest_cutoff]
    test_data, test_data_index = data[traintest_cutoff:], data_index[
        traintest_cutoff:]
    #print(test_data)
    col_mbs = 1 + 3 * netcfg.num_lte_bs_mobile + 1
    zeros = np.zeros(col_mbs)
    #print('zeros', zeros)
    ones = np.ones(col_mbs)

    esn = ESN(
        n_inputs=col_mbs,
        n_outputs=1,
        n_reservoir=14,
        spectral_radius=0.25,
        sparsity=0.25,
        noise=0.001,
        input_shift=zeros,
        input_scaling=ones,
        #input_scaling=[1, 1],
        teacher_scaling=0.5,
        #teacher_scaling=1,
        teacher_shift=-0,
        #teacher_shift=0,
        # teacher_scaling = None,
        # teacher_shift = None,
        out_activation=np.tanh,
        inverse_out_activation=np.arctanh,
        random_state=rng,
        silent=False)

    print('----------------------------------------------------------------')
    print('esn {}'.format(index2 + 1))
    print('----------------------------------------------------------------')

    print('n_inputs=', esn.n_inputs)
    print('n_outputs=', esn.n_outputs)
    print('n_reservoir=', esn.n_reservoir)
    print('spectral radius=', esn.spectral_radius)
    print('sparsity=', esn.sparsity)
    print('noise=', esn.noise)
    print('input_shift=', esn.input_shift)
    print('input_scaling=', esn.input_scaling)
    print('teacher_forcing=', esn.teacher_forcing)
    # print ('feedback_scaling=' , esn1.feedback_scaling)
    print('teacher_scaling=', esn.teacher_scaling)
    print('teacher_shift=', esn.teacher_shift)
    print('out_activation=', esn.out_activation)
    print('inverse_out=', esn.inverse_out_activation)
    print('random_state=', esn.random_state)
    print('silent=', esn.silent)

    pred_train = esn.fit(train_data, train_data_index)
    pred_test = esn.predict(test_data)
    #print('b',pred_test*2*data_index_max)
    predicted_index = pred_test * 2 * data_index_max
    #print(predicted_index)
    pp.figure(2)
    axis = (netcfg.num_lte_bs_mobile * 100) + 10 + (index2 + 1)
    pp.subplot(axis)
    #pp.title('MBS {}'.format (index2+1))
    #pp.title('ESN Performance for Predicting Next Best Location Index')
    pp.xlabel('Number of iterations')
    pp.ylabel('Next Location Index Value')
    pp.ylim(0, 400)
    #pp.plot(range(len(test_data)), test_data_index*2*data_index_max, range(len(pred_test)), pred_test*2*data_index_max)
    pp.plot(range(len(test_data_index)),
            test_data_index * 2 * data_index_max,
            c='r',
            marker='o',
            label='Exhaustive Search')
    pp.plot(range(len(test_data_index)),
            predicted_index,
            c='g',
            linestyle='--',
            label='ESN-Opt')
    pp.xlabel('Network Run Time (slot)')
    pp.ylabel('Location Index')
    pp.grid(True)
    pp.legend()
          random_state = rng,
          silent = False)

print('fitting')
pred_train = esn.fit(u, y)

#Assess Training Error     
vec_bounder = np.vectorize(bounder)
bounded = vec_bounder(pred_train)

#print(bounded)
#print('\n', y.reshape(lengthTrain, parity-1))
boundedErrors = np.abs(bounded - y.reshape(lengthTrain, parity-1))
numWrong = sum([1 if xi != 0 else 0 for xi in np.sum(boundedErrors, axis = 1)])
print('Number Wrong (Training):', numWrong, 'Out of', lengthTrain, '\n')


#Testing
(uTest,yTest) = generateParity(lengthTest, parity)
pred_test = esn.predict(uTest)
print('Testing MSE:',np.sqrt(np.mean((pred_test - yTest)**2)))

boundedTest = vec_bounder(pred_test)
boundedTestErrors = np.abs(boundedTest - yTest.reshape(lengthTest, parity-1))
numWrongTest = sum([1 if xi != 0 else 0 for xi in np.sum(boundedTestErrors, axis = 1)])

#print(boundedTest)
#print('\n', yTest.reshape(lengthTest, parity-1))

print('Number Wrong (Testing):', numWrongTest, 'Out of', lengthTest, '\n')
def esn_training(index, data, ntwk_obj):
    '''ESN Training for each MBS'''
    #print(index)
    num = netcfg.num_lte_bs_mobile - netcfg.num_lte_bs

    #print(num)
    index = index - (netcfg.num_lte_bs_mobile - num)
    #print(index)
    col_mbs = 3 * netcfg.num_lte_bs_mobile + 1 + index
    #print('a',col_mbs)
    #print('all data',data)

    data_rate = data[:, col_mbs:col_mbs + 1]
    #print('data_rate',data_rate)

    data = data[:, 0:col_mbs - index]
    #print('intermediate',data)

    data = np.hstack((data, data_rate))

    #print('data',data)

    coord_x = ntwk_obj.grid_x_coord
    #print(coord_x,'\n')
    coord_y = ntwk_obj.grid_y_coord
    #print(coord_y,'\n')

    #data_rate = np.transpose(data_rate)
    #print(data_rate)
    #print('data',data)
    data_rate = data[:, col_mbs - index]
    #print(data_rate)
    data_rate_max = max(data_rate)
    #print('max',data_rate_max)
    #exit(0)
    ntwk_obj.max_data = data_rate_max
    #print(ntwk_obj.max_data)
    data_rate = data_rate / data_rate_max / 2
    #print(data_rate)
    data_rate = np.transpose(np.array([data_rate]))
    #print('data rate',data_rate)

    N = netcfg.total_tick

    rng = np.random.RandomState(42)
    traintest_cutoff = int(np.ceil(0.8 * N))
    train_data, train_data_rate = data[:
                                       traintest_cutoff], data_rate[:
                                                                    traintest_cutoff]
    #print('train data',train_data)
    #print('train data rate',train_data_rate)
    #print('train data',train_data.shape)
    #print('train data rate',train_data_rate.shape)
    test_data, test_data_rate = data[traintest_cutoff:], data_rate[
        traintest_cutoff:]
    #print('test data',test_data)
    #print('test data rate',test_data_rate)
    p1 = sum(test_data_rate)
    print('p1', p1)
    #print('test data',test_data.shape)
    #print('test data rate',test_data_rate.shape)
    col_mbs = col_mbs + 1 - index
    zeros_row = np.zeros(col_mbs)
    #print('zeros', zeros)
    ones_row = np.ones(col_mbs)
    #print('ones', ones)
    #print(col_mbs)
    # create an echo state network
    esn = ESN(
        n_inputs=col_mbs,
        n_outputs=1,
        n_reservoir=21,
        spectral_radius=0.25,
        sparsity=0.25,
        noise=0.001,
        input_shift=zeros_row,
        input_scaling=ones_row,
        #input_scaling=[1, 1],
        teacher_scaling=0.5,
        #teacher_scaling=1,
        teacher_shift=-0,
        #teacher_shift=0,
        # teacher_scaling = None,
        # teacher_shift = None,
        out_activation=np.tanh,
        inverse_out_activation=np.arctanh,
        random_state=rng,
        silent=False)

    # print('----------------------------------------------------------------')
    # print ('esn {}'.format(index+1))
    # print('----------------------------------------------------------------')

    # print ('n_inputs=', esn.n_inputs)
    # print ('n_outputs=', esn.n_outputs)
    # print ('n_reservoir=', esn.n_reservoir)
    # print ('spectral radius=', esn.spectral_radius)
    # print ('sparsity=', esn.sparsity)
    # print ('noise=', esn.noise)
    # print ('input_shift=', esn.input_shift)
    # print ('input_scaling=', esn.input_scaling)
    # print ('teacher_forcing=', esn.teacher_forcing)
    # # print ('feedback_scaling=' , esn1.feedback_scaling)
    # print ('teacher_scaling=', esn.teacher_scaling)
    # print ('teacher_shift=', esn.teacher_shift)
    # print ('out_activation=', esn.out_activation)
    # print ('inverse_out=', esn.inverse_out_activation)
    # print ('random_state=', esn.random_state)
    # print ('silent=', esn.silent)

    #print('1')
    # fitting

    pred_train = esn.fit(train_data, train_data_rate)

    #print(pred_train)
    #print('2')
    # prediction
    #print(data.shape)

    pred_test = esn.predict(test_data)

    # print('data rate',data_rate)
    # print('pred test',pred_test,'\n')
    # print('3')
    pp.figure(1)
    font = {'family': 'sans', 'size': 16}
    pp.rc('font', **font)
    axis = (netcfg.num_lte_bs_mobile * 100) + 10 + (index + 1)
    pp.subplot(axis)
    #pp.title('MBS {}'.format (index+1))
    #pp.title('ESN Performance for Rate Prediction')
    pp.xlabel('Network Run Time (slot)')
    pp.ylabel('FBS Rate (Mbps)')
    # print(data_rate)
    # print(pred_test)

    pp.plot(range(len(test_data_rate)),
            test_data_rate * 2 * data_rate_max,
            c='r',
            marker='o',
            label='Measured Rate')
    pp.plot(range(len(test_data_rate)),
            pred_test * 2 * data_rate_max,
            c='g',
            linestyle='--',
            label='ESN-Pdt Prediction')
    pp.legend()
    pp.grid(True)
    return esn
Example #17
0
    n_outputs=
    n_features,  #Número de saídas (produtos) utilizadas na rede. Neste caso, são iguais.
    n_reservoir=n_reservoir,
    sparsity=sparsity,
    random_state=1,
    spectral_radius=spectral_radius,
    noise=noise)
##

#Primeira predição:
trainlen = 130  #Quantidade de pontos (dias) a serem usados para treino
future = 30  #Quantidade de pontos (dias) a serem previstos.

pred_training0 = esn.fit(np.ones((trainlen, n_features)),
                         data[:trainlen, :trainlen])
prediction0 = esn.predict(np.ones((future, n_features)))
errorlist0, errormean0 = results(
    data, prediction0, trainlen, future, plotfigures=False
)  #Se desejar ver os erros e plotar gráficos para comparar predições, setar plotfigures = True.
#

#Início de otimização de parâmetros. São quatro variáveis: n_reservoir, sparsity, spectral_radius e noise.
#Primeiramente são buscados o melhor par de spectral_radius e noise, onde melhor significa ter menor RMSE.
#Serão mantidos fixos n_reservoir e sparsity.
n_reservoir = 1000  #Atenção: aumentar n_reservoir aumenta muito o tempo computacional.
sparsity = 0.3

#Conjunto de spectral_radius linearmente espaçado entre 1 e 1.8:
radiusset = [
    1, 1.05, 1.1, 1.15, 1.2, 1.25, 1.3, 1.35, 1.4, 1.45, 1.5, 1.55, 1.6, 1.65,
    1.7, 1.75, 1.8
Example #18
0
File: mackey.py Project: gwli/pyESN
from pyESN import ESN
from matplotlib import pyplot as plt

data = np.load(
    'mackey_glass_t17.npy')  #  http://minds.jacobs-university.de/mantas/code
esn = ESN(n_inputs=1,
          n_outputs=1,
          n_reservoir=500,
          spectral_radius=1.5,
          random_state=42)

trainlen = 2000
future = 2000
pred_training = esn.fit(np.ones(trainlen), data[:trainlen])

prediction = esn.predict(np.ones(future))
print("test error: \n" + str(
    np.sqrt(
        np.mean((prediction.flatten() -
                 data[trainlen:trainlen + future])**2))))

plt.figure(figsize=(11, 1.5))
plt.plot(range(0, trainlen + future),
         data[0:trainlen + future],
         'k',
         label="target system")
plt.plot(range(trainlen, trainlen + future),
         prediction,
         'r',
         label="free running ESN")
lo, hi = plt.ylim()
def esn_training(index, data, ntwk_obj):
    '''ESN Training for each MBS'''
    #print(index)
    num = netcfg.num_lte_bs_mobile - netcfg.num_lte_bs

    #print(num)
    index = index - (netcfg.num_lte_bs_mobile - num)
    #print(index)
    col_mbs = 3 * netcfg.num_lte_bs_mobile + 1 + index
    #print('a',col_mbs)
    #print('all data',data)

    data_rate = data[:, col_mbs:col_mbs + 1]
    #print('data_rate',data_rate)

    data = data[:, 0:col_mbs - index]
    #print('intermediate',data)

    data = np.hstack((data, data_rate))
    #print('data',data)

    coord_x = ntwk_obj.grid_x_coord
    #print(coord_x,'\n')
    coord_y = ntwk_obj.grid_y_coord
    #print(coord_y,'\n')

    length = len(coord_x)
    #print(length)
    length1 = len(coord_y)
    #print(length)
    #print(length1)
    #xyz_coord = np.array([1]
    xyz_data = np.array([])
    z = 100
    utility = 0

    for i in range(length):
        xyz_coord = np.array([1])
        for num in range(netcfg.num_lte_bs_mobile):
            #print(i)
            #print(length)
            j = i + num
            #print(j)
            if j < length:
                #print(j)
                x = coord_x[j]
                y = coord_y[j]
                xy = np.hstack((x, y))
                xyz = np.hstack((xy, z))
                #xyz_coord = np.hstack((xyz_coord,xyz))
                #print('a',xyz_coord)
            else:
                #print('j',j)
                j = j - length
                #print('j',j)
                x = coord_x[j]
                y = coord_y[j]
                xy = np.hstack((x, y))
                xyz = np.hstack((xy, z))
                #xyz_coord = np.hstack((xyz_coord,xyz))
                #print('b',xyz_coord)

            #print(xyz)
            if num == 0:
                #print(xyz_coord)
                xyz = np.hstack((1, xyz))
                data_xyz = xyz
                #print(data_xyz)
            else:
                data_xyz = np.hstack((data_xyz, xyz))
                #print(data_xyz)

        data_xyz = np.hstack((data_xyz, utility))
        #print(data_xyz)
        #print(i)
        if i == 0:
            xyz_coord_data = data_xyz
            #print(xyz_coord_data)
        else:
            xyz_coord_data = np.vstack((xyz_coord_data, data_xyz))
            #print(xyz_coord_data)

    #print(data)
    print(xyz_coord_data)
    data = np.vstack((data, xyz_coord_data))
    #print(data)

    #data_rate = np.transpose(data_rate)
    #print(data_rate)
    #print('data',data)
    data_rate = data[:, col_mbs - index]
    #print(data_rate)
    data_rate_max = max(data_rate)
    #print('max',data_rate_max)
    #exit(0)

    data_rate = data_rate / data_rate_max / 2
    #print(data_rate)
    data_rate = np.transpose(np.array([data_rate]))
    #print('data rate',data_rate)

    N = netcfg.total_tick

    rng = np.random.RandomState(42)
    traintest_cutoff = int(np.ceil(N))
    train_data, train_data_rate = data[:N], data_rate[:N]
    #print('train data',train_data)
    #print('train data rate',train_data_rate)
    #print('train data',train_data.shape)
    #print('train data rate',train_data_rate.shape)
    test_data, test_data_rate = data[N:], data_rate[N:]
    #print('test data',test_data)
    #print('test data rate',test_data_rate)
    #print('test data',test_data.shape)
    #print('test data rate',test_data_rate.shape)
    col_mbs = col_mbs + 1 - index
    zeros = np.zeros(col_mbs)
    #print('zeros', zeros)
    ones = np.ones(col_mbs)
    #print('ones', ones)

    # create an echo state network
    esn = ESN(
        n_inputs=col_mbs,
        n_outputs=1,
        n_reservoir=475,
        spectral_radius=0.25,
        sparsity=0.25,
        noise=0.001,
        input_shift=zeros,
        input_scaling=ones,
        #input_scaling=[1, 1],
        teacher_scaling=1.50,
        #teacher_scaling=1,
        teacher_shift=-0.7,
        #teacher_shift=0,
        # teacher_scaling = None,
        # teacher_shift = None,
        out_activation=np.tanh,
        inverse_out_activation=np.arctanh,
        random_state=rng,
        silent=False)

    print('----------------------------------------------------------------')
    print('esn {}'.format(index + 1))
    print('----------------------------------------------------------------')

    print('n_inputs=', esn.n_inputs)
    print('n_outputs=', esn.n_outputs)
    print('n_reservoir=', esn.n_reservoir)
    print('spectral radius=', esn.spectral_radius)
    print('sparsity=', esn.sparsity)
    print('noise=', esn.noise)
    print('input_shift=', esn.input_shift)
    print('input_scaling=', esn.input_scaling)
    print('teacher_forcing=', esn.teacher_forcing)
    # print ('feedback_scaling=' , esn1.feedback_scaling)
    print('teacher_scaling=', esn.teacher_scaling)
    print('teacher_shift=', esn.teacher_shift)
    print('out_activation=', esn.out_activation)
    print('inverse_out=', esn.inverse_out_activation)
    print('random_state=', esn.random_state)
    print('silent=', esn.silent)

    #print('1')
    # fitting
    pred_train = esn.fit(train_data, train_data_rate)

    #print('2')
    # prediction
    pred_test = esn.predict(data)
    #print(pred_test)
    #print('data rate',data_rate)
    #print('pred test',pred_test,'\n')
    #print('3')
    #pp.figure(1)
    axis = (netcfg.num_lte_bs_mobile * 100) + 10 + (index + 1)
    pp.subplot(axis)
    pp.title('MBS {}'.format(index + 1))
    #print(data_rate)
    #print(pred_test)
    pp.plot(range(len(data)), data_rate, range(len(pred_test)), pred_test)
Example #20
0
    def test_freqgen(self):
        rng = np.random.RandomState(42)

        def frequency_generator(N, min_period, max_period, n_changepoints):
            """returns a random step function + a sine wave signal that
               changes its frequency at each such step."""
            # vector of random indices < N, padded with 0 and N at the ends:
            changepoints = np.insert(
                np.sort(rng.randint(0, N, n_changepoints)),
                [0, n_changepoints], [0, N])
            # list of interval boundaries between which the control sequence
            # should be constant:
            const_intervals = list(zip(changepoints, np.roll(changepoints,
                                                             -1)))[:-1]
            # populate a control sequence
            frequency_control = np.zeros((N, 1))
            for (t0, t1) in const_intervals:
                frequency_control[t0:t1] = rng.rand()
            periods = frequency_control * \
                (max_period - min_period) + max_period

            # run time through a sine, while changing the period length
            frequency_output = np.zeros((N, 1))
            z = 0
            for i in range(N):
                z = z + 2 * np.pi / periods[i]
                frequency_output[i] = (np.sin(z) + 1) / 2
            return np.hstack([np.ones((N, 1)),
                              1 - frequency_control]), frequency_output

        N = 15000
        min_period = 2
        max_period = 10
        n_changepoints = int(N / 200)
        frequency_control, frequency_output = frequency_generator(
            N, min_period, max_period, n_changepoints)

        traintest_cutoff = int(np.ceil(0.7 * N))
        train_ctrl, train_output = frequency_control[:
                                                     traintest_cutoff], frequency_output[:
                                                                                         traintest_cutoff]
        test_ctrl, test_output = frequency_control[
            traintest_cutoff:], frequency_output[traintest_cutoff:]

        esn = ESN(n_inputs=2,
                  n_outputs=1,
                  n_reservoir=200,
                  spectral_radius=0.25,
                  sparsity=0.95,
                  noise=0.001,
                  input_shift=[0, 0],
                  input_scaling=[0.01, 3],
                  teacher_scaling=1.12,
                  teacher_shift=-0.7,
                  out_activation=np.tanh,
                  inverse_out_activation=np.arctanh,
                  random_state=rng,
                  silent=True)

        pred_train = esn.fit(train_ctrl, train_output)
        # print "test error:"
        pred_test = esn.predict(test_ctrl)
        error = np.sqrt(np.mean((pred_test - test_output)**2))
        self.assertAlmostEqual(error, 0.30519018985725715)
def esn_training(index, data_mbs):
    '''ESN Training for each MBS'''

    col_mbs = 3 * netcfg.num_lte_bs_mobile + index
    data_mbs = data_mbs[:, col_mbs]
    #print(data_rate,'\n')
    data_mbs_max = max(data_mbs)
    #print(data_mbs_1_rate_max,'\n')

    data_mbs = data_mbs / data_mbs_max / 2
    #print(data_mbs_1_rate,'\n')

    data_mbs = np.transpose(np.array([data_mbs]))
    #print(data_mbs_1_rate,'\n')

    N = 10000
    rng = np.random.RandomState(42)
    traintest_cutoff = int(np.ceil(0.6 * N))
    train_data, train_data_mbs = data[:
                                      traintest_cutoff], data_mbs[:
                                                                  traintest_cutoff]
    test_data, test_data_mbs = data[traintest_cutoff:], data_mbs[
        traintest_cutoff:]
    col_mbs = col_mbs + 1
    #print('n = ', col_mbs)
    zeros = np.zeros(col_mbs)
    #print('zeros', zeros)
    ones = np.ones(col_mbs)
    #print('ones', ones)
    #exit(0)
    # create an echo state network
    esn = ESN(
        n_inputs=col_mbs,
        n_outputs=1,
        n_reservoir=200,
        spectral_radius=0.25,
        sparsity=0.25,
        noise=0.001,
        input_shift=zeros,
        input_scaling=ones,
        #input_scaling=[1, 1],
        teacher_scaling=2.0,
        #teacher_scaling=1,
        teacher_shift=-0.9,
        #teacher_shift=0,
        # teacher_scaling = None,
        # teacher_shift = None,
        out_activation=np.tanh,
        inverse_out_activation=np.arctanh,
        random_state=rng,
        silent=False)

    print('----------------------------------------------------------------')
    print('esn {}'.format(i + 1))
    print('----------------------------------------------------------------')

    print('n_inputs=', esn.n_inputs)
    print('n_outputs=', esn.n_outputs)
    print('n_reservoir=', esn.n_reservoir)
    print('spectral radius=', esn.spectral_radius)
    print('sparsity=', esn.sparsity)
    print('noise=', esn.noise)
    print('input_shift=', esn.input_shift)
    print('input_scaling=', esn.input_scaling)
    print('teacher_forcing=', esn.teacher_forcing)
    # print ('feedback_scaling=' , esn1.feedback_scaling)
    print('teacher_scaling=', esn.teacher_scaling)
    print('teacher_shift=', esn.teacher_shift)
    print('out_activation=', esn.out_activation)
    print('inverse_out=', esn.inverse_out_activation)
    print('random_state=', esn.random_state)
    print('silent=', esn.silent)

    #print('1')
    # fitting
    pred_train = esn.fit(train_data, train_data_mbs)
    #print('2')
    # prediction
    pred_test = esn.predict(data)
    #print('3')
    pp.plot(range(len(data)), data_mbs, range(len(pred_test)), pred_test)
    #print('4')
    pp.title('MBS no. {}'.format(i + 1))
    #print('5')
    pp.show()
Example #22
0
          spectral_radius = 0.25,
          sparsity = 0.95,
          noise = 0.001,
          input_shift = [0,0],
          input_scaling = [0.01, 3],
          teacher_scaling = 1.12,
          teacher_shift = -0.7,
          out_activation = np.tanh,
          inverse_out_activation = np.arctanh,
          random_state = rng,
          silent = False)

pred_train = esn.fit(train_ctrl,train_output)

print("test error:")
pred_test = esn.predict(test_ctrl)
print(np.sqrt(np.mean((pred_test - test_output)**2)))

window_tr = range(int(len(train_output)/4),int(len(train_output)/4+2000))
plt.figure(figsize=(10,1.5))
plt.plot(train_ctrl[window_tr,1],label='control')
plt.plot(train_output[window_tr],label='target')
plt.plot(pred_train[window_tr],label='model')
plt.legend(fontsize='x-small')
plt.title('training (excerpt)')
plt.ylim([-0.1,1.1])

window_test = range(2000)
plt.figure(figsize=(10,1.5))
plt.plot(test_ctrl[window_test,1],label='control')
plt.plot(test_output[window_test],label='target')
Example #23
0
    Y = np.asarray(Y)
    trainX = X[:half_range]
    trainY = Y[:half_range]
    testX = X[half_range:]
    testY = Y[half_range:]

    ne_list = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000]
    for ne in ne_list:
        print("neurons num: %d" % (ne))
        esn = ESN(n_inputs=5,
                  n_outputs=1,
                  n_reservoir=ne,
                  spectral_radius=1.5,
                  random_state=42)
        esn_train = esn.fit(trainX, trainY)
        esn_pred = esn.predict(testX)
        print("esn error: \n" +
              str(np.sqrt(np.mean((esn_pred.flatten() - testY)**2))))

        mlp = MLPRegressor(alpha=0.1,
                           hidden_layer_sizes=(ne, ),
                           max_iter=1000,
                           activation='logistic',
                           learning_rate='constant',
                           learning_rate_init=0.01)
        mlp_train = mlp.fit(trainX, trainY)
        mlp_pred = mlp.predict(testX)
        print("mlp error: \n" +
              str(np.sqrt(np.mean((mlp_pred.flatten() - testY)**2))))

        sgd = MLPRegressor(alpha=0.1,