Notes 20110120 CIS 6050 Neural Networks

From SnOwy - Ed's Wiki Notebook

Contents 1 Administrivia 2 Architectures 2.1 Competitive learning 2.2 Boltzmann Learning 2.3 Back Propagation 2.3.1 Encoding Patterns into Weights

Administrivia

• Assignment 1 -- due soon
• Lit review -- due soon

Architectures

• k-NN -- the representations are actually transparent and human interpretable
• looks like an associative array

Competitive learning

• Self organizing maps
• Adaptive resonance theory
• output nodes compete to become active
• usually only one node can remain active simultaneously
• each output is responsible for a specific group of patterns
• normal feed forward training with the addition of lateral inhibitory nodes
• interlayer connections are excitatory
• intralayer connections are inhibitory
• the winning node has the highest activation
• losing nodes have their activations set to zero
• learning occurs on weight attached only to the winning node k.
• Δ { η(x_j - w_k,j if k is winner; 0 if k is loser }
• over time, the weight vector w_k moves toward the input pattern x
• we can then look at the weights that literally describe the desired input patterns
• as opposed to the back propagation networks
• this may not be perfect if the input vectors are dramatically different

Boltzmann Learning

• recurrent structure
• binary nodes -- nodes are on and off
• calculates an energy value ...
• E = 0.5 Σ_jΣ_kw_kjx_kx_j
• where x_k, x_j are node states (activation)
• w_kj -- weights connecting them
• nodes are flipped at random
• changes are kept if they reduce E
• the difference between desired and actual behaviour is used to adjust weights

Back Propagation

• at least three layers of nodes are needed
• i.e. two weight layers are needed
• input layer F_A (F is field)
• hidden layer F_B
• output layer F_C
• normally completely connected
• input-output pairs are presented to the network in FA
• activations created in FB
• outputs created in FC
• weights adjusted to associate input patterns to output patterns
• requires many iterations

Encoding Patterns into Weights

1. initialization
   • assign random values in [-1, +1] to all weights between FA and FB; FB and FC -- Vhi and Wij
   • each node in FB and FC also have threshold values Θ_i and Γ_j (also randomized)
   • notation: Weight layers have been given V and W; thresholds have been given Θ and Γ
2. input pattern given to FA
   • call it A_k
   • calculate the FB, FC
   • b_i = f( Σ_h=1ⁿa_iv_hi+Θ_i )
     • b_i -- FB activation for each node
     • a_i -- activation values for each input node
     • v_hi -- weights between FA and FB
     • Θ_i -- threshold for FB
     • f() sigmoid function ...
   • sigmoid function -- bounds the values
     • f(x) → (1 + e^-x)^-1
     • logistic sigmoid function
3. calculate output activation
   • pass FB through w_ij to FC
   • c_j = f (Σ_i=1^mb_iw_ij+Γ_j)
     • ... infer
4. learning starts
   • calculate the error at the FC layer
   • the difference between the seen c_j and desired outputs c_j^k
   • d_j = c_j(1-c_j)(c_j^k-c_j)
5. calculate the errors in the hidden layer
   • e_i = b_i(1-b_i)Σ_j=1^qw_ijd_j
6. adjusting the weights between FB and FC
   • w_ij between FB and FC
   • ΔW_ij = αb_id_j
     • where b_i connects to w_ij connects to d_j
     • α is the learning rate (learning constant) -- is a small number
7. adjusting the weights between FA and FB
   • ΔV_ij = βa_he_i
     • β is a learning constant (often equal to α)
8. adjust the thresholds
   • Θ = βe_i
   • Γ = αd_j

• repeat steps 2 to 8 until error is arbitrarily low (or failure, whereupon you restart)
• for recall -- do steps 2 and 3 -- generates activation in FC with no change to the weights