Beispiel #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
Beispiel #2
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)
Beispiel #3
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)
Beispiel #4
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)
Beispiel #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))
Beispiel #6
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))
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
Beispiel #9
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]))
Beispiel #10
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]))
Beispiel #11
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()
          n_outputs = parity - 1,
          n_reservoir = 300,
#          spectral_radius = 0.25,
          sparsity = 0.9,
          noise = 0.01,
#          input_shift = input_shift,
#          input_scaling = [0.01],
#          teacher_scaling = 1.12,
          teacher_shift = -0.7,
          out_activation = np.tanh,
          inverse_out_activation = np.arctanh,
          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)
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
Beispiel #14
0
        rho = radius_set[l]
        for j in range(reservoir_set_size):
            n_reservoir = reservoir_set[j]
            future = k_set[v]
            pred_tot=np.zeros(futureTotal)

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

            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]
            
            loss[v, l, j] = MSE(pred_tot, data[trainlen-1:trainlen+futureTotal-1])        
            print('window = ', k_set[v],'rho = ', radius_set[l], ', reservoir_sixe = ', reservoir_set[j], ', MSE = ', loss[v][l][j] )


# In[39]:


parameters=[]
for i in range(k_size):
    minloss=np.min(loss[i])
    index_min=np.where(loss[i]==minloss)
    spec=index_min[0]
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)
Beispiel #16
0
from pyESN import ESN
import driving_utils

x_data, y_data = driving_utils.getData("/train_data/aalborg.csv")
x_data1, y_data1 = driving_utils.getData("/train_data/alpine-1.csv")
x_data2, y_data2 = driving_utils.getData("/train_data/f-speedway.csv")
print(x_data.shape)
print(x_data1.shape)
print(x_data2.shape)
print(y_data.shape)
print(y_data1.shape)
print(y_data2.shape)

x_data = np.concatenate((x_data, x_data1), axis=0)
x_data = np.concatenate((x_data, x_data2), axis=0)
y_data = np.concatenate((y_data, y_data1), axis=0)
y_data = np.concatenate((y_data, y_data2), axis=0)
print(y_data.shape)
print(x_data.shape)
rng = np.random.RandomState(42)
esn = ESN(n_inputs=22,
          n_outputs=3,
          n_reservoir=2000,
          spectral_radius=1.5,
          random_state=42)
esn.fit(x_data, y_data, inspect=True)


def predict(X):
    return esn.predict(X)
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()
Beispiel #18
0
import numpy as np
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")
Beispiel #19
0
train_len = 1100
future = 10
futureTotal = 30
pred_tot_abbank = np.zeros(futureTotal)
pred_tot_bankasia = np.zeros(futureTotal)
pred_tot_ebl = np.zeros(futureTotal)
pred_tot_dutchbangl = np.zeros(futureTotal)
pred_tot_ific = np.zeros(futureTotal)
pred_tot_jamunabank = np.zeros(futureTotal)
pred_tot_mtb = np.zeros(futureTotal)
pred_tot_nccbank = np.zeros(futureTotal)
pred_tot_southeast = np.zeros(futureTotal)
pred_tot_ucb = np.zeros(futureTotal)

for i in range(0, futureTotal, future):
    pred_training = esn.fit(np.ones(train_len), dfabbank_N[i:train_len + i])
    prediction = esn.predict(np.ones(future))
    pred_tot_abbank[i:i + future] = prediction[:, 0]

for i in range(0, futureTotal, future):
    pred_training = esn.fit(np.ones(train_len), dfbankasia_N[i:train_len + i])
    prediction = esn.predict(np.ones(future))
    pred_tot_bankasia[i:i + future] = prediction[:, 0]

for i in range(0, futureTotal, future):
    pred_training = esn.fit(np.ones(train_len), dfebl_N[i:train_len + i])
    prediction = esn.predict(np.ones(future))
    pred_tot_ebl[i:i + future] = prediction[:, 0]

for i in range(0, futureTotal, future):
    pred_training = esn.fit(np.ones(train_len),
Beispiel #20
0
esn = ESN(
    n_inputs=n_features,  #Número de entradas (produtos) utilizadas na rede.
    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,
Beispiel #21
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
Beispiel #22
0
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 = 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)
Beispiel #23
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)
Beispiel #24
0
    X = np.asarray(X)
    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))))