شبکه عصبی مصنوعی و پیاده‌سازی در پایتون — راهنمای کاربردی

1import numpy as np
2class Perceptron:
3    
4    def __init__(self, input_length, weights=None):
5        if weights is None:
6            self.weights = np.ones(input_length) * 0.5
7        else:
8            self.weights = weights
9        
10    @staticmethod
11    def unit_step_function(x):
12        if x > 0.5:
13            return 1
14        return 0
15        
16    def __call__(self, in_data):
17        weighted_input = self.weights * in_data
18        weighted_sum = weighted_input.sum()
19        return Perceptron.unit_step_function(weighted_sum)
20    
21p = Perceptron(2, np.array([0.5, 0.5]))
22for x in [np.array([0, 0]), np.array([0, 1]), 
23          np.array([1, 0]), np.array([1, 1])]:
24    y = p(np.array(x))
25    print(x, y)

1[0 0] 0
2[0 1] 0
3[1 0] 0
4[1 1] 1

1import numpy as np
2from collections import Counter
3class Perceptron:
4    
5    def __init__(self, input_length, weights=None):
6        if weights==None:
7            self.weights = np.random.random((input_length)) * 0.5
8        self.learning_rate = 0.1
9        
10    @staticmethod
11    def unit_step_function(x):
12        if x < 0:
13            return 0
14        return 1
15        
16    def __call__(self, in_data):
17        weighted_input = self.weights * in_data
18        weighted_sum = weighted_input.sum()
19        return Perceptron.unit_step_function(weighted_sum)
20    
21    def adjust(self, 
22               target_result, 
23               calculated_result,
24               in_data):
25        error = target_result - calculated_result
26        for i in range(len(in_data)):
27            correction = error * in_data[i] *self.learning_rate
28            self.weights[i] += correction 
29     
30def above_line(point, line_func):
31    x, y = point
32    if y > line_func(x):
33        return 1
34    else:
35        return 0
36  
37points = np.random.randint(1, 100, (100, 2))
38p = Perceptron(2)
39def lin1(x):
40    return  x
41for point in points:
42    p.adjust(above_line(point, lin1), 
43             p(point), 
44             point)
45evaluation = Counter()
46for point in points:
47    if p(point) == above_line(point, lin1):
48        evaluation["correct"] += 1
49    else:
50        evaluation["wrong"] += 1
51print(evaluation.most_common())
52# the following line is only needed,
53# if you use "ipython notebook":
54#matplotlib inline 
55from matplotlib import pyplot as plt
56cls = [[], []]
57for point in points:
58    cls[above_line(point, lin1)].append(tuple(point))
59colours = ("r", "b")
60for i in range(2):
61    X, Y = zip(*cls[i])
62    plt.scatter(X, Y, c=colours[i])
63    
64X = np.arange(-3, 120)
65    
66plt.plot(X, lin1(X), label="line1")
67plt.legend()
68plt.show()

1[('correct', 99), ('wrong', 1)]

1import numpy as np
2from collections import Counter
3class Perceptron:
4    
5    def __init__(self, input_length, weights=None):
6        if weights==None:
7            self.weights = np.random.random((input_length)) * 2 - 1
8        self.learning_rate = 0.1
9        
10    @staticmethod
11    def unit_step_function(x):
12        if x < 0:
13            return 0
14        return 1
15        
16    def __call__(self, in_data):
17        weighted_input = self.weights * in_data
18        weighted_sum = weighted_input.sum()
19        return Perceptron.unit_step_function(weighted_sum)
20    
21    def adjust(self, 
22               target_result, 
23               calculated_result,
24               in_data):
25        error = target_result - calculated_result
26        for i in range(len(in_data)):
27            correction = error * in_data[i] *self.learning_rate
28            self.weights[i] += correction 
29     
30def above_line(point, line_func):
31    x, y = point
32    if y > line_func(x):
33        return 1
34    else:
35        return 0
36  
37points = np.random.randint(1, 100, (100, 2))
38p = Perceptron(2)
39def lin1(x):
40    return  x 
41for point in points:
42    p.adjust(above_line(point, lin1), 
43             p(point), 
44             point)
45evaluation = Counter()
46for point in points:
47    if p(point) == above_line(point, lin1):
48        evaluation["correct"] += 1
49    else:
50        evaluation["wrong"] += 1
51print(evaluation.most_common())

1('correct', 93), ('wrong', 7)]

1# the following line is only needed,
2# if you use "ipython notebook":
3%matplotlib inline 
4from matplotlib import pyplot as plt
5cls = [[], []]
6for point in points:
7    cls[above_line(point, lin1)].append(tuple(point))
8colours = ("r", "b")
9for i in range(2):
10    X, Y = zip(*cls[i])
11    plt.scatter(X, Y, c=colours[i])
12    
13X = np.arange(-3, 120)
14    
15m = -p.weights[0] / p.weights[1]
16print(m)
17plt.plot(X, m*X, label="ANN line")
18plt.plot(X, lin1(X), label="line1")
19plt.legend()
20plt.show()

11.11082111934

1import numpy as np
2from matplotlib import pyplot as plt
3npoints = 50
4X, Y = [], []
5# class 0
6X.append(np.random.uniform(low=-2.5, high=2.3, size=(npoints,)) )
7Y.append(np.random.uniform(low=-1.7, high=2.8, size=(npoints,)))
8# class 1
9X.append(np.random.uniform(low=-7.2, high=-4.4, size=(npoints,)) )
10Y.append(np.random.uniform(low=3, high=6.5, size=(npoints,)))
11learnset = []
12for i in range(2):
13    # adding points of class i to learnset
14    points = zip(X[i], Y[i])
15    for p in points:
16        learnset.append((p, i))
17colours = ["b", "r"]
18for i in range(2):
19    plt.scatter(X[i], Y[i], c=colours[i])
20from collections import Counter
21class Perceptron:
22    
23    def __init__(self, input_length, weights=None):
24        if weights==None:
25            self.weights = np.random.random((input_length)) * 2 - 1
26        self.learning_rate = 0.1
27        
28    @staticmethod
29    def unit_step_function(x):
30        if x < 0:
31            return 0
32        return 1
33        
34    def __call__(self, in_data):
35        weighted_input = self.weights * in_data
36        weighted_sum = weighted_input.sum()
37        return Perceptron.unit_step_function(weighted_sum)
38    
39    def adjust(self, 
40               target_result, 
41               calculated_result,
42               in_data):
43        error = target_result - calculated_result
44        for i in range(len(in_data)):
45            correction = error * in_data[i] *self.learning_rate
46            self.weights[i] += correction 
47     
48  
49p = Perceptron(2)
50for point, label in learnset:
51    p.adjust(label, 
52             p(point), 
53             point)
54evaluation = Counter()
55for point, label in learnset:
56    if p(point) == label:
57        evaluation["correct"] += 1
58    else:
59        evaluation["wrong"] += 1
60print(evaluation.most_common())
61colours = ["b", "r"]
62for i in range(2):
63    plt.scatter(X[i], Y[i], c=colours[i])
64XR = np.arange(-8, 4)  
65m = -p.weights[0] / p.weights[1]
66print(m)
67plt.plot(XR, m*XR, label="decision boundary")
68plt.legend()
69plt.show()

1[('correct', 77), ('wrong', 23)]
23.10186712936

1import numpy as np
2from matplotlib import pyplot as plt
3npoints = 50
4X, Y = [], []
5# class 0
6X.append(np.random.uniform(low=-2.5, high=2.3, size=(npoints,)) )
7Y.append(np.random.uniform(low=-1.7, high=2.8, size=(npoints,)))
8# class 1
9X.append(np.random.uniform(low=-7.2, high=-4.4, size=(npoints,)) )
10Y.append(np.random.uniform(low=3, high=6.5, size=(npoints,)))
11learnset = []
12for i in range(2):
13    # adding points of class i to learnset
14    points = zip(X[i], Y[i])
15    for p in points:
16        learnset.append((p, i))
17colours = ["b", "r"]
18for i in range(2):
19    plt.scatter(X[i], Y[i], c=colours[i])
20    
21import numpy as np
22from collections import Counter
23class Perceptron:
24    
25    def __init__(self, input_length, weights=None):
26        if weights==None:
27            # input_length + 1 because bias needs a weight as well
28            self.weights = np.random.random((input_length + 1)) * 2 - 1
29        self.learning_rate = 0.05
30        self.bias = 1
31    
32    @staticmethod
33    def sigmoid_function(x):
34        res = 1 / (1 + np.power(np.e, -x))
35        return 0 if res < 0.5 else 1
36        
37    def __call__(self, in_data):
38        weighted_input = self.weights[:-1] * in_data
39        weighted_sum = weighted_input.sum() + self.bias *self.weights[-1]
40        return Perceptron.sigmoid_function(weighted_sum)
41    
42    def adjust(self, 
43               target_result, 
44               calculated_result,
45               in_data):
46        error = target_result - calculated_result
47        for i in range(len(in_data)):
48            correction = error * in_data[i]  *self.learning_rate
49            #print("weights: ", self.weights)
50            #print(target_result, calculated_result, in_data, error, correction)
51            self.weights[i] += correction 
52        # correct the bias:
53        correction = error * self.bias * self.learning_rate
54        self.weights[-1] += correction 
55     
56  
57p = Perceptron(2)
58for point, label in learnset:
59    p.adjust(label, 
60             p(point), 
61             point)
62evaluation = Counter()
63for point, label in learnset:
64    if p(point) == label:
65        evaluation["correct"] += 1
66    else:
67        evaluation["wrong"] += 1
68print(evaluation.most_common())
69colours = ["b", "r"]
70for i in range(2):
71    plt.scatter(X[i], Y[i], c=colours[i])
72XR = np.arange(-8, 4)  
73m = -p.weights[0] / p.weights[1]
74b = -p.weights[-1]/p.weights[1]
75print(m, b)
76plt.plot(XR, m*XR + b, label="decision boundary")
77plt.legend()
78plt.show()

1[('correct', 89), ('wrong', 11)]
2(-4.4747085666259885, -5.9570317327705196)