You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
326 lines
6.9 KiB
Markdown
326 lines
6.9 KiB
Markdown
# Classes and methods
|
|
|
|
|
|
```python
|
|
class Dog:
|
|
# init method
|
|
def __init__(self, dogName, dogAge):
|
|
self.name = dogName
|
|
self.age = dogAge
|
|
pass
|
|
|
|
def status(self):
|
|
print("The dog's name is: ", self.name)
|
|
print("The dog's age is: ", self.age)
|
|
```
|
|
|
|
|
|
```python
|
|
dog1 = Dog("firulais", 8)
|
|
dog2 = Dog("Perro", 2)
|
|
dog3 = Dog("cuadrado", 5)
|
|
```
|
|
|
|
|
|
```python
|
|
dog3.status()
|
|
```
|
|
|
|
The dog's name is: cuadrado
|
|
The dog's age is: 5
|
|
|
|
|
|
|
|
```python
|
|
|
|
```
|
|
|
|
# ANN class implementation
|
|
|
|
|
|
```python
|
|
class Neurona:
|
|
# init
|
|
def __init__():
|
|
pass
|
|
# feedforward (cálculo)
|
|
def feedforward():
|
|
pass
|
|
# backpropagation (entrenamiento)
|
|
def backpropagation():
|
|
pass
|
|
|
|
```
|
|
|
|
|
|
```python
|
|
import numpy as np
|
|
|
|
class Neurona:
|
|
# init
|
|
def __init__(self, inputNodes, hiddenNodes, outputNodes):
|
|
self.inN = inputNodes
|
|
self.hN = hiddenNodes
|
|
self.outN = outputNodes
|
|
##
|
|
## W = w11 w21
|
|
self.wih = np.random.rand(self.hN, self.inN)
|
|
self.who = np.random.rand(self.outN, self.hN)
|
|
pass
|
|
# feedforward (cálculo)
|
|
def feedforward():
|
|
pass
|
|
# backpropagation (entrenamiento)
|
|
def backpropagation():
|
|
pass
|
|
|
|
```
|
|
|
|
|
|
```python
|
|
inputs = np.array([0.21,0.39, 0.87],ndmin=2).T
|
|
inputs
|
|
```
|
|
|
|
|
|
|
|
|
|
array([[0.21],
|
|
[0.39],
|
|
[0.87]])
|
|
|
|
|
|
|
|
|
|
```python
|
|
import numpy as np
|
|
class Neurona:
|
|
# init
|
|
def __init__(self, inputNodes, hiddenNodes, outputNodes):
|
|
self.inN = inputNodes
|
|
self.hN = hiddenNodes
|
|
self.outN = outputNodes
|
|
##
|
|
## W = w11 w21
|
|
self.wih = np.random.rand(self.hN, self.inN)-0.5
|
|
self.who = np.random.rand(self.outN, self.hN)-0.5
|
|
pass
|
|
# feedforward (cálculo)
|
|
def feedforward(self, Inputs):
|
|
#Xh
|
|
self.inputs = np.array(Inputs, ndmin=2).T
|
|
self.Xh = np.dot(self.wih, self.inputs)
|
|
self.af = lambda x:1/(1+np.exp(-x))
|
|
#Oh
|
|
self.Oh = self.af(self.Xh)
|
|
|
|
#Xo
|
|
self.Xo = np.dot(self.who, self.Oh)
|
|
#Oh
|
|
self.Oo = self.af(self.Xo)
|
|
#Oo
|
|
pass
|
|
# backpropagation (entrenamiento)
|
|
def backpropagation(self, Inputs, Targets, Learning):
|
|
lr = Learning
|
|
self.inputs = np.array(Inputs, ndmin=2).T
|
|
self.targets = np.array(Targets, ndmin=2).T
|
|
#Xh
|
|
self.Xh = np.dot(self.wih, self.inputs)
|
|
self.af = lambda x:1/(1+np.exp(-x))
|
|
#Oh
|
|
self.Oh = self.af(self.Xh)
|
|
|
|
#Xo
|
|
self.Xo = np.dot(self.who, self.Oh)
|
|
#Oh
|
|
self.Oo = self.af(self.Xo)
|
|
#Oo
|
|
|
|
# output error
|
|
oe = self.targets-self.Oo
|
|
he = np.dot(self.who.T, oe)
|
|
self.who=self.who+lr*np.dot(oe*self.Oo*(1-self.Oo), self.Oh.T)
|
|
self.wih=self.wih+lr*np.dot(he*self.Oh*(1-self.Oh), self.inputs.T)
|
|
pass
|
|
```
|
|
|
|
|
|
```python
|
|
mynn = Neurona(3,5,3)
|
|
mynn.backpropagation([0.21, 0.39, 0.87], [0.12, 0.10, 0.99], 0.3)
|
|
mynn.who
|
|
```
|
|
|
|
|
|
|
|
|
|
array([[0.89962766, 0.94344371, 0.25520613, 0.50403018, 0.79841922],
|
|
[0.46742312, 0.8497042 , 0.72150451, 0.4832481 , 0.1614701 ],
|
|
[0.07348318, 0.74125584, 0.96294501, 0.6829789 , 0.99122929]])
|
|
|
|
|
|
|
|
|
|
```python
|
|
mynn.backpropagation([0.21, 0.39, 0.87], [0.12, 0.10, 0.99], 0.3)
|
|
mynn.who
|
|
```
|
|
|
|
|
|
|
|
|
|
array([[0.88622924, 0.92904876, 0.24001207, 0.48936863, 0.78475758],
|
|
[0.45035738, 0.83136916, 0.70215163, 0.46457349, 0.14406909],
|
|
[0.07510425, 0.74299748, 0.96478333, 0.68475279, 0.9928822 ]])
|
|
|
|
|
|
|
|
# Mnist database
|
|
|
|
|
|
```python
|
|
data_file = open("mnist_train.csv", 'r')
|
|
data_list = data_file.readlines()
|
|
data_file.close
|
|
data_list
|
|
```
|
|
|
|
|
|
**Output ommited due to its length**
|
|
|
|
|
|
```python
|
|
import numpy as np
|
|
import matplotlib.pyplot as plt
|
|
values = data_list[30600].split(',')
|
|
image = np.asfarray(values[1:]).reshape((28,28))
|
|
plt.imshow(image)
|
|
plt.show()
|
|
```
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
```python
|
|
values[0]
|
|
```
|
|
|
|
|
|
|
|
|
|
'1'
|
|
|
|
|
|
|
|
## Training
|
|
|
|
|
|
```python
|
|
# hyper-parameters:
|
|
inputNodes = 784
|
|
hiddenNodes = 100
|
|
outputNodes = 10
|
|
learningRate = 0.1
|
|
myANN = Neurona(inputNodes, hiddenNodes, outputNodes)
|
|
```
|
|
|
|
|
|
```python
|
|
myANN.wih[:,0]
|
|
```
|
|
|
|
|
|
|
|
|
|
array([ 3.80810137e-01, -2.76021452e-01, 1.89578510e-01, -4.40622523e-01,
|
|
4.49345620e-04, -2.99576867e-02, 2.88898176e-01, 1.00257001e-01,
|
|
-1.25427321e-01, -4.10841382e-01, 1.01058830e-01, -4.19682107e-01,
|
|
-2.61884751e-01, -4.86639132e-01, -4.10475994e-01, 4.72554845e-01,
|
|
-2.58545906e-01, 2.12843730e-01, 4.77632343e-01, 4.85691685e-01,
|
|
-2.21585439e-01, 1.43760970e-01, -2.23361202e-01, -3.69871226e-01,
|
|
-1.21973032e-01, -4.29052035e-01, -3.97413451e-01, 4.65864914e-01,
|
|
-1.26186271e-01, 2.07401026e-01, 1.05937271e-01, 1.46875776e-01,
|
|
2.95015245e-01, 3.43457017e-02, -3.29510246e-01, -2.48072947e-01,
|
|
-3.64935302e-01, 3.09460892e-01, -5.01871329e-02, 2.98023264e-01,
|
|
-3.19341252e-01, -3.90225500e-02, 3.10060197e-01, -3.13901381e-01,
|
|
3.69558936e-01, -1.38918625e-01, -4.78037558e-01, 9.24705861e-02,
|
|
-1.34122723e-01, -8.70299561e-02, -3.93637460e-02, 3.81876093e-01,
|
|
-8.53474718e-02, -1.29582776e-01, -4.02245397e-01, -4.56054710e-01,
|
|
2.64854223e-02, -1.53704117e-01, 1.90609293e-01, 3.62048289e-01,
|
|
-6.25482544e-02, 3.82745274e-01, 1.43009716e-01, 1.75700493e-01,
|
|
4.09349632e-01, -4.89451563e-01, -9.27621754e-02, 1.41559919e-01,
|
|
1.34585537e-01, -2.86828229e-01, 3.44307471e-01, -4.98223666e-01,
|
|
-4.05137857e-01, 1.81890913e-01, -4.57908080e-01, 4.87169160e-01,
|
|
-2.11761055e-01, 3.18985378e-02, -3.00127711e-01, 4.80807855e-01,
|
|
-2.70966977e-01, 2.36741392e-02, -3.03853361e-01, -4.29846112e-02,
|
|
5.33828969e-02, 2.18366071e-01, 2.13736555e-01, -1.15094147e-01,
|
|
-2.41327435e-02, 3.40917056e-01, 3.76097667e-02, -5.77225150e-03,
|
|
-3.83882298e-01, -2.31975044e-01, 2.44874629e-01, 7.90940279e-02,
|
|
-2.92400249e-01, 4.53702317e-01, 8.09984361e-02, -4.93878547e-02])
|
|
|
|
|
|
|
|
|
|
```python
|
|
epoch = 1
|
|
for e in range(epoch):
|
|
for record in data_list:
|
|
values = record.split(',')
|
|
inputData = (np.asfarray(values[1:])/255*0.99) +0.01
|
|
target = np.zeros(outputNodes)+0.01
|
|
target[int(values[0])] = 0.99
|
|
myANN.backpropagation(inputData, target, learningRate)
|
|
pass
|
|
pass
|
|
```
|
|
|
|
|
|
```python
|
|
len(data_list)
|
|
```
|
|
|
|
|
|
|
|
|
|
49999
|
|
|
|
|
|
|
|
|
|
```python
|
|
values = data_list[30600].split(',')
|
|
inputData = (np.asfarray(values[1:])/255*0.99) +0.01
|
|
myANN.feedforward(inputData)
|
|
```
|
|
|
|
|
|
```python
|
|
myANN.Oo
|
|
```
|
|
|
|
|
|
|
|
|
|
array([[2.42193187e-02],
|
|
[1.11760730e-01],
|
|
[5.09994337e-01],
|
|
[4.44172963e-02],
|
|
[3.37977872e-04],
|
|
[3.97805262e-03],
|
|
[1.06099919e-03],
|
|
[3.15328122e-02],
|
|
[1.33289159e-01],
|
|
[2.44129745e-03]])
|
|
|
|
|
|
|
|
|
|
```python
|
|
|
|
```
|