示例#1
0
def worker(input_worker):
    """Explanations"""
    #Global variables:
    global numInput,numOutput,numHidden
    global dim_hidden_output, dim_hidden_output
    global sigma
    global env
    
    #Local:
    
    seed = int(input_worker[0])
    p = input_worker[1]
    
    env.seed(seed) 
    np.random.seed(seed)
    
    #Neural Networks:
    NN = NeuralNetwork(numInput,numHidden,numOutput, VBN_dict)
    
    NN.wi=p[0]
    NN.wo=p[1]
    
    #distortions
    
    epsilon = np.random.multivariate_normal(np.zeros(dim_hidden_output+dim_input_hidden),np.identity(dim_hidden_output+dim_input_hidden))
    epsilon_wo= epsilon[0:dim_hidden_output].reshape((numHidden,numOutput))
    epsilon_wi= epsilon[dim_hidden_output:dim_hidden_output+dim_input_hidden].reshape((numInput,numHidden))

    
    #epsilon_wo = np.random.multivariate_normal([0 for x in range(dim_hidden_output)],np.identity(dim_hidden_output)).reshape((numHidden,numOutput))
    #epsilon_wi = np.random.multivariate_normal([0 for x in range(dim_input_hidden)],np.identity(dim_input_hidden)).reshape((numInput,numHidden))
    
    #parameters update
    NN.wo=NN.wo+epsilon_wo*sigma #remark:we should merge the two, and reshape the matrix
    NN.wi=NN.wi+epsilon_wi*sigma
    
    #initial_observation=env.reset()
    
    reward_worker=episodeRoute(NN,env,initial_observation,steps=250)
    
    
    return(reward_worker,epsilon_wi,epsilon_wo)
示例#2
0
def worker_train_VBN(input_worker_VBN):
    """Explanations"""
    #Global variables:
    global numInput,numOutput,numHidden
    global dim_hidden_output, dim_hidden_output
    global env
    
    
    #Local:

    seed=int(input_worker_VBN[0])
    p = input_worker_VBN[1]
    
    env.seed(seed) 
    #np.random.seed(seed)    
    VBN_dict = {}
    VBN_dict['mu_i']=0
    VBN_dict['var_i']=0
    VBN_dict['mu_h']=0
    VBN_dict['var_h']=0
    VBN_dict['mu_o']=0
    VBN_dict['var_o']=0    
    
    
    #Neural Networks:
    NN = NeuralNetwork(numInput,numHidden,numOutput, VBN_dict)    
    NN.wi=p[0]
    NN.wo=p[1]
    
    steps=250
    ai = env.reset()  
    num_step=steps
    
    for j in range(steps):
        
        ao = NN.feedForward(ai)
        #to transfer to the main 
        # question: how many worker for this ?
        
        sum_zi=[0.] * numInput        
        sum_zh=[0.] * numHidden  
        sum_zo=[0.] *numOutput
        sum_zi2=[0.] * numInput        
        sum_zh2=[0.] * numHidden  
        sum_zo2=[0.] *numOutput
        
 
        
        sum_zi=[sum(x) for x in zip(sum_zi, NN.zi)]   ### VERY WEIRD !! ALWAYS EQUAL TO 1 ?
        sum_zh=[sum(x) for x in zip(sum_zh, NN.zh)]
        sum_zo=[sum(x) for x in zip(sum_zo, NN.zo)]
        
        sum_zi2=[sum(x) for x in zip(sum_zi2, square(NN.zi))]
        sum_zh2=[sum(x) for x in zip(sum_zh2, square(NN.zh))]
        sum_zo2=[sum(x) for x in zip(sum_zo2, square(NN.zo))]
        
        '''
        sum_zi=map(add, sum_zi, NN.zi)
        sum_zh=map(add, sum_zh, NN.zh)
        sum_zo=map(add, sum_zo, NN.zo)
        
        sum_zi=map(add, sum_zi2, square(NN.zi))
        sum_zh=map(add, sum_zh2, square(NN.zh))
        sum_zo=map(add, sum_zo2, square(NN.zo))
        '''
        
                
        action=np.argmax(ao)      
        ai, reward, done, info = env.step(action)
        
        if done:
            break
            num_step=j     
            
    return(sum_zi,sum_zh,sum_zo,sum_zi2,sum_zh2,sum_zo2,num_step)