Artificial Neural Networks using Julia

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

1. type NeuralLayer
   
2.     w::Matrix{Float64}   # weights
   
3.     b::Vector{Float64}   # biases
   
4.     a_func::Function     # activation function
   
5.     a_derv::Function     # activation funciton derivative
   
6. 
   
7.     # The following must be tracked for back propagation
   
8.     hx::Vector{Float64}  # input values
   
9.     pa::Vector{Float64}  # pre activation values
   
10.     pr::Vector{Float64}  # predictions (activation values)
    
11.     # Gradients
    
12.     wgr::Matrix{Float64} # weight gradient
    
13.     bgr::Vector{Float64} # bias gradient
    
14. end
    
15. 
    
16. 
    
17. # sigmoidal activation function
    
18. function sigm(a::Vector{Float64})
    
19.     1. ./ (1. + exp(-a))
    
20. end
    
21. 
    
22. # sigmoid derivative
    
23. function sigm_derv(a::Vector{Float64})
    
24.     s_a = sigm(a)
    
25.     s_a .* (1. - s_a)
    
26. end
    
27. 
    
28. function NeuralLayer(in_dim::Integer,out_dim::Integer)
    
29.     # Glorot & Bengio, 2010
    
30.     b = sqrt(6) / sqrt(in_dim + out_dim)
    
31.     NeuralLayer(2b * rand(out_dim,in_dim) - b,
    
32.                 zeros(out_dim),
    
33.                 sigm,
    
34.                 sigm_derv,
    
35. 
    
36.                 zeros(in_dim),
    
37.                 zeros(out_dim),
    
38.                 zeros(out_dim),
    
39. 
    
40.                 zeros(out_dim,in_dim),
    
41.                 zeros(out_dim)
    
42.     )
    
43. end
    
44. 
    
45. type ArtificialNeuralNetwork
    
46.     layers::Vector{NeuralLayer}
    
47.     hidden_sizes::Vector{Int64} # Number of nodes in each hidden level
    
48.     classes::Vector{Int64}
    
49. end
    
50. 
    
51. function softmax(ann_output::Vector{Float64})
    
52.     # Takes the output of a neural network and produces a valid
    
53.     # probability distribution
    
54.     ann_output = exp(ann_output)
    
55.     ann_output / sum(ann_output)
    
56. end
    
57. 
    
58. function ArtificialNeuralNetwork(n_hidden_units::Integer)
    
59.     ann = ArtificialNeuralNetwork(Array(NeuralLayer,0),
    
60.                                  [n_hidden_units],
    
61.                                  Array(Int64,0))
    
62. end
    
63. 
    
64. function forward_propagate(nl::NeuralLayer,x::Vector{Float64})
    
65.     nl.hx = x
    
66.     nl.pa = nl.b + nl.w * x
    
67.     nl.pr = nl.a_func(nl.pa)
    
68. end
    
69. 
    
70. function back_propagate(nl::NeuralLayer,output_gradient::Vector{Float64})
    
71.     nl.wgr = output_gradient * nl.hx' # compute weight gradient
    
72.     nl.bgr = output_gradient # compute bias gradient
    
73.     nl.w' * output_gradient # return gradient of level below
    
74. end
    
75. 
    
76. function init!(ann::ArtificialNeuralNetwork,
    
77.                      x::Matrix{Float64},
    
78.                      y::Vector{Int64})
    
79.     layers = Array(NeuralLayer,length(ann.hidden_sizes) + 1)
    
80.     ann.classes = unique(y)
    
81.     sort!(ann.classes)
    
82.     input_dim = size(x)[2]
    
83.     for i = 1:length(ann.hidden_sizes)
    
84.         out_dim = ann.hidden_sizes[i]
    
85.         layers[i] = NeuralLayer(input_dim,out_dim)
    
86.         input_dim = out_dim
    
87.     end
    
88.     layers[length(layers)] = NeuralLayer(input_dim,length(ann.classes))
    
89.     layers[length(layers)].a_func = softmax
    
90.     ann.layers = layers
    
91.     ann
    
92. end
    
93. 
    
94. function fit!(ann::ArtificialNeuralNetwork,
    
95.               x::Matrix{Float64},
    
96.               y::Vector{Int64};
    
97.               epochs::Int64 = 5,
    
98.               alpha::Float64 = 0.1,
    
99.               lambda::Float64 = 0.1)
    
100.     init!(ann,x,y)
     
101.     n_obs, n_feats = size(x)
     
102.     layers = ann.layers
     
103.     n_layers = length(layers)
     
104.     for _ = 1:epochs
     
105.         for i = 1:n_obs
     
106.             y_hat = zeros(length(ann.classes))
     
107.             y_hat[findfirst(ann.classes,y[i])] = 1.
     
108. 
     
109.             y_pred = predict(ann,x[i,:][:])
     
110.             output_gradient = -(y_hat - y_pred)
     
111.             for j = n_layers:-1:2
     
112.                 # This returns the gradient of the j-1 layer
     
113.                 next_layer_gr = back_propagate(layers[j],output_gradient)
     
114.                 next_layer = layers[j-1]
     
115.                 output_gradient = next_layer_gr .* next_layer.a_derv(next_layer.pa)
     
116.             end
     
117.             back_propagate(layers[1],output_gradient)
     
118. 
     
119.             # Compute delta and step
     
120.             for j = 1:n_layers
     
121.                 nl = layers[j]
     
122.                 # Computer L2 weight penatly
     
123.                 weight_delta = (-nl.wgr) - (lambda * (2 * nl.w))
     
124.                 nl.w = alpha * weight_delta + nl.w
     
125.                 nl.b = alpha * (-nl.bgr) + nl.b
     
126.             end
     
127.         end
     
128.     end
     
129. end
     
130. 
     
131. 
     
132. # Predict class probabilities for a given observation
     
133. function predict(ann::ArtificialNeuralNetwork,x::Vector{Float64})
     
134.     for i in 1:length(ann.layers)
     
135.         x = forward_propagate(ann.layers[i],x)
     
136.     end
     
137.     x
     
138. end
     
139. 
     
140. # Handle a Matrix input
     
141. function predict(ann::ArtificialNeuralNetwork,x::Matrix{Float64})
     
142.     n_obs,n_feats = size(x)
     
143.     y_proba = zeros((n_obs,length(ann.classes)))
     
144.     for i = 1:n_obs
     
145.         y_proba[i,:] = predict(ann,x[i,:][:])
     
146.     end
     
147.     y_proba
     
148. end

复制代码

In machine learning and cognitive science, artificial neural networks (ANNs) are a family of statistical learning algorithms inspired by biological neural networks (the central nervous systems of animals, in particular thebrain) and are used to estimate or approximate functions that can depend on a large number of inputs and are generally unknown. Artificial neural networks are generally presented as systems of interconnected "neurons" which can compute values from inputs, and are capable of machine learning as well as pattern recognition thanks to their adaptive nature.

For example, a neural network for handwriting recognition is defined by a set of input neurons which may be activated by the pixels of an input image. After being weighted and transformed by a function[disambiguation needed](determined by the network's designer), the activations of these neurons are then passed on to other neurons. This process is repeated until finally, an output neuron is activated. This determines which character was read.

Like other machine learning methods - systems that learn from data - neural networks have been used to solve a wide variety of tasks that are hard to solve using ordinary rule-based programming, including computer vision and speech recognition.

Perhaps the greatest advantage of ANNs is their ability to be used as an arbitrary function approximation mechanism that 'learns' from observed data. However, using them is not so straightforward, and a relatively good understanding of the underlying theory is essential.

• Choice of model: This will depend on the data representation and the application. Overly complex models tend to lead to problems with learning.
• Learning algorithm: There are numerous trade-offs between learning algorithms. Almost any algorithm will work well with the correct hyperparameters for training on a particular fixed data set. However, selecting and tuning an algorithm for training on unseen data requires a significant amount of experimentation.
• Robustness: If the model, cost function and learning algorithm are selected appropriately the resulting ANN can be extremely robust.
  

With the correct implementation, ANNs can be used naturally in online learning and large data set applications. Their simple implementation and the existence of mostly local dependencies exhibited in the structure allows for fast, parallel implementations in hardware.

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏2 回帖

关键词：Artificial Networks network Neural Works following function gradient Vector Matrix