Python kezdetek
Funkciók
Az első 2 sort a # miatt kihagyja, a def segítségével tudunk csinálni egy, a későbbiekben használatos funkciót, aminek a nev az ‘avg’, későbbiekben így tudunk majd hivatkozni rá. A zárójelben lévő x és y azt jelenti, hogy a python a 2 bemenetet kér és a későbbiekben, a funkción belül így kell rájuk hivatkozni. Amik a funkción belül beljebb vannak tolva az maga az amit a program el fog végezni. A végén a ‘return’ azt jelenti, hogy ‘a’-t egy outputként fogja kidobni a program, amire szintén fogunk majd tudni hivatkozni.
Ahhoz, hogy ezt tudjuk használni ezt meg kell hívnunk, mivel önmagában ez nem csinál semmit csak tárolja a funciót.
# Ez egy olyan funkció ami 2 számot kér bemenetnek
# és az átlagukat adja ki
def avg(x,y):
print(f"Az első bemenet a(z) {x}")
print(f"A második bemenet a(z) {y}")
a = (x+y)/2.0
print(f"Az átlaguk pedig {a}")
return a
avg(2,4)
Az első bemenet a(z) 2 A második bemenet a(z) 4 Az átlaguk pedig 3.0
3.0
Array – sorok,rendszerek
Neurális hálózatnál gyakran használunk mátrixokat mindenhez is, ezekhez fogjuk segítségül hívni a legismertebb ilyen könyvtárat, a numpy-t.
import numpy as np
#Létrehozunk egy 3*2-es mátrixot, ami csak nullákat tartalmaz.
a = np.zeros([3,2])
print(a)
[[0. 0.] [0. 0.] [0. 0.]]
#Most megváltoztatjuk az értékeit egyes részeinek a mátrixnak
a[0, 0] = 1
a[0, 1] = 2
a[2, 1] = 9
a[1, 0] = 11
print(a)
[[ 1. 2.] [11. 0.] [ 0. 9.]]
#Így kell kiírni az adott értékei a mátrixnak
print(a[0,1])
v = a[1, 0]
print(v)
2.0 11.0
Vizuális megjelenítés
Van lehetőségünk egyes sorokat, rendszerek az átláthatóság kedvéért vizuálisan is megjeleníteni.
Az egyik legtöbbet használni ilyen megjelenítő a matplotlib, amit ugyanúgy be kell importálni mint a numpy-t.
import matplotlib.pyplot as plt
#Ez csak az interaktív környezetben kell, máshol nem
%matplotlib inline
#Ahhoz, hogy egy ilyen megjelenítést csináljunk az imshow parancsot használjuk
#Az első paramétere a mátrix amit meg akarunk jeleníteni
plt.imshow(a)
#plt.imshow(a, interpolation="nearest") --> ez az interpolation nem tudom mire jó
#Színek szerint megmutatta nekünk a mátrixot,és annak a 2 mátrixnak megegyezik a színe aminek ugyanaz az értéke
<matplotlib.image.AxesImage at 0x7f796eb8e150>
Objektumok
Hasonlítanak a funkciókhoz, mivel ezeket is egyszer létrehozzuk, utána pedig többször tudjuk őket használni, de sokkal többet tudnak azoknál.
#Létrehozunk egy dog osztályt objektumként
class dog:
#a kutyák tudnak ugatni
def bark(self):
print("woof")
pass
pass
Amint látható, a kutya osztályon belül is van egy funkció.
sizzles = dog()
sizzles.bark()
létrehoztuk a sizzles változót, amihez hozzárendeltük a dog osztályt, ennek következtébe belelátunk ebbe az osztályba, így elérjük a benne lévő funkciókat. Ezeket a változókat hívjuk objektumoknak.
Ez a “self”, amit beleírtunk annyit takar, hogy amikor a python létrehozza az funkciókat, akkor a jó objektumhoz rendelje hozzá
sizzles = dog()
mutley = dog()
sizzles.bark()
mutley.bark()
woof woof
Úgy lehet ezt értelmezni, hogy az osztályok torta receptek egy szakácskönyvből, és az objektumok azok a torták maguk, amiket azzal a recepttel csináltak meg.
Ezután nézzük még mit lehet csinálni az osztályokkal és objektumokkal. Most hozzunk létre újra egy kutya osztályt és adjunk hozzá különböző funkciókat.
# a dog objektumnak egy osztály
class Dog:
#kezdő metódus a belső adatokkal
def __init__(self, petname, temp):
self.name = petname;
self.temperature = temp;
#nézzük meg a kutya állapotát
def status(self):
print(f"A kutya neve: {self.name}")
print(f"A kutya hőmérséklete: {self.temperature}")
pass
#állítsuk be a hőmérsékletét
def setTemperature(self, temp):
self.temperature = temp;
pass
# a kutya még mindig tud ugatni
def bark(self):
print("woof!")
Hozzáadtunk 3 új funciót a kutya osztályhoz, eddig is megvolt a bark(), de most még az init(), a status(), és a setTemperature(). De bármi féle funkciót hozzá tudunk adni ehhez amit szeretnénk.
De ezeknél változó nevek is vannak megadva a funkción belül. Ezeket paramétereknek nevezzük, és ezeket várja a funkció amikor meghívjuk őket. Az avg() funkciónál is két változót vártunk a megadásra.
Itt látszik, hogy az init()-nek 2 paraméter, a petname és a temp, míg a setTemperature()-nek csak a temp értéket kell megadni meghíváskor.
Nézzük meg őket egyesével:
- Az init funkció egy speciális python funkció, amit mindig meghív amikor egy objektumot csinál. Ezen belül mi csinálunk 2 változót a self.name és a self.temperature-t. Ezeknek hozzárendeljük a temp és a name változót. A self része azt jelenti, hogy ezek részei változók részei a részei ennek az objektumnak. Ezek csak annak az objektumnak a részei és függetlenek más Dog objetumoktól. Nem akarjuk összekerevni a kutyáink neveit.
- A status() nagyon egyszerű, nem kér egy paramétert sem, csak egyszerűen kiírja a kutya nevét és hőmérsékletét.
- Végül pedig a setTemperature() egy paramétert kér be. Amint látjuk egybeállítja a self.temperature-t ahhoz amit ennél megadtunk. Ennek segítségével bármikor megváltoztathatjuk a objektum hőmérsékletét és bárhányszor.
Most hozzunk létre egy új kutyát a lassie változóba és a nevezzük el Lassie-nek és állítsunk be neki egy kezdő hőmérsekletet, 37-et.
#létrehozunk egy új kutya objektumot a Dog osztályból
lassie = Dog("Lassie", 37)
#most lekérdezzük ennek a lassienek a státuszát
lassie.status()
A kutya neve: Lassie A kutya hőmérséklete: 37
Amint látjuk, amint a status() funkció kiírja a nevét illetve a hőmérsékletét. Most pedig változtassuk meg a hőmérsékletét
lassie.setTemperature(40)
lassie.status()
A kutya neve: Lassie A kutya hőmérséklete: 40
Amint látjuk, a setTemperature() tényleg megváltoztatta a belső változó értékét
Neurális hálózatok Pythonnal
A kinézete a neurális hálóknak:
Kell legalább 3 funkció:
- Inicializáció: megadjuk a bemeneti értékek, a rejtett és a kimeneti értékek számát.
- Train: A súlyok újrahangolása miután mutattunk neki példákat
- Query: Ad egy választ a bementi értékünkre
Ez nem tökéletes, de nagy vonalakban így kell kezdeni
#adjuk meg a neuralális hálózat definícióját
class neuralNetwork:
#Inicializáljuk a házózatot
def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):
#álllítsuk be őket, hogy eltárolja
self.inodes = inputnodes
self.hnodes = hiddennodes
self.onodes = outputnodes
self.lr = learningrate
pass
#Edzük a neurális hálózatot
def train():
pass
#Kérjük le a megoldást
def query():
pass
Csináljunk egy basic neurális hálózat objektumot, amiben 3 node van minden szinten.
input_nodes = 3
hidden_nodes = 3
output_nodes = 3
learning_rate = 0.5
Basic = neuralNetwork(input_nodes, hidden_nodes, output_nodes, learning_rate)
Súlyok – A szíve a hálózatnak
Ezt most mátrixokkal tesszük meg, ebben az esetben 2 mátrixunk lesz, egy a bemeneti és a rejtett értékek között és egy a rejtett és a kimeneti értékek között.
Fontos, hogy a súlyok kezdetben kicsit és randomok legyenek, így a numpy segítségével fogunk létrehozni random számokat.
np.random.rand(3,3)
array([[0.42748036, 0.33559864, 0.02113717],
[0.22994128, 0.67489871, 0.13186922],
[0.23652387, 0.61701452, 0.61352941]])
Ez mind szép és jó, de a súlyok lehetnek minuszak is, szóval kivonunk belőlunk 0.5-öt ésí így bevisszük a -0.5 – 0.5 tartományba
np.random.rand(3,3) - 0.5
array([[-0.07292068, -0.4011541 , -0.19254256],
[ 0.09218389, -0.33310393, 0.17444327],
[-0.13644314, 0.23299552, -0.00531007]])
Ezeket a súlyokat bele kell építenünk az inicializáicióba is, hogy kezdésenk mindig ott legyen és tovább éljen az objektumban. Ezt egy kicsit szofisztikáltabban építjük bele, méghozzá a normális eloszlás segítségével
import scipy.special
#adjuk meg a neuralális hálózat definícióját
class neuralNetwork:
#Inicializáljuk a házózatot
def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):
#álllítsuk be őket, hogy eltárolja
self.inodes = inputnodes
self.hnodes = hiddennodes
self.onodes = outputnodes
self.lr = learningrate
self.wih = np.random.normal(0.0, pow(self.inodes, -0.5), (self.hnodes, self.inodes))
#Az aktivációs fgv a szigmoid fgv.
self.who = np.random.normal(0.0, pow(self.hnodes, -0.5), (self.onodes, self.hnodes))
self.activation_function = lambda x: scipy.special.expit(x)
pass
#Edzük a neurális hálózatot
def train():
pass
#Kérjük le a megoldást
def query(self, inputs_list):
inputs = np.array(inputs_list, ndmin=2).T
#kiszámoljuk az értékeke a nem látható szintbe
hidden_inputs = np.dot(self.wih, inputs)
#számoljuk ki az értékeket a nem látható szintrő jőve
hidden_outputs = self.activation_function(hidden_inputs)
#kiszámoljuk az értékekek a végső kimeneti layerbe
final_inputs = np.dot(self.who, hidden_outputs)
final_output = self.activation_function(final_inputs)
return final_output
input_nodes = 4
hidden_nodes = 4
output_nodes = 3
learning_rate = 3
Test = neuralNetwork(input_nodes, hidden_nodes, output_nodes, learning_rate)
Test.query([2.3, 2.1, -1, 5])
array([[0.46555633],
[0.4972548 ],
[0.61305252]])
Sajnos valamiért a beágyazása a Google Collaboratory-nak nem működik rendesen, de a bal felső sarokban lévő ikonnal meglehet tekinteni és szerkeszteni. Illetve a GitHub-on is meglehet nézni.