PyBrain - การทดสอบเครือข่าย

ในบทนี้เราจะมาดูตัวอย่างที่เราจะฝึกอบรมข้อมูลและทดสอบข้อผิดพลาดของข้อมูลที่ผ่านการฝึกอบรม

เราจะใช้ประโยชน์จากผู้ฝึกสอน -

BackpropTrainer

BackpropTrainer เป็นเทรนเนอร์ที่ฝึกพารามิเตอร์ของโมดูลตามชุดข้อมูลภายใต้การดูแลหรือ ClassificationDataSet (อาจเป็นลำดับต่อเนื่อง) โดย backpropagating ข้อผิดพลาด (ตามเวลา)

TrainUntilConvergence

ใช้เพื่อฝึกโมดูลบนชุดข้อมูลจนกว่าจะบรรจบกัน

เมื่อเราสร้างเครือข่ายประสาทเทียมเครือข่ายจะได้รับการฝึกอบรมตามข้อมูลการฝึกอบรมที่กำหนดตอนนี้การฝึกอบรมเครือข่ายอย่างเหมาะสมหรือไม่นั้นขึ้นอยู่กับการคาดคะเนของข้อมูลทดสอบที่ทดสอบบนเครือข่ายนั้น

ให้เราดูตัวอย่างการทำงานทีละขั้นตอนซึ่งจะสร้างเครือข่ายประสาทเทียมและทำนายข้อผิดพลาดในการฝึกอบรมข้อผิดพลาดในการทดสอบและข้อผิดพลาดในการตรวจสอบความถูกต้อง

ทดสอบเครือข่ายของเรา

ต่อไปนี้เป็นขั้นตอนที่เราจะปฏิบัติตามเพื่อทดสอบเครือข่ายของเรา -

• การนำเข้า PyBrain และแพ็คเกจอื่น ๆ ที่จำเป็น
• สร้าง ClassificationDataSet
• แยกชุดข้อมูล 25% เป็นข้อมูลทดสอบและ 75% เป็นข้อมูลที่ฝึกอบรม
• การแปลง Testdata และข้อมูลการฝึกอบรมกลับเป็น ClassificationDataSet
• การสร้าง Neural Network
• ฝึกอบรมเครือข่าย
• แสดงข้อผิดพลาดและข้อมูลการตรวจสอบความถูกต้อง
• เปอร์เซ็นต์สำหรับข้อผิดพลาดของข้อมูลทดสอบ

Step 1

การนำเข้า PyBrain และแพ็คเกจอื่น ๆ ที่จำเป็น

แพ็คเกจที่เราต้องการจะถูกนำเข้าตามที่แสดงด้านล่าง -

from sklearn import datasets
import matplotlib.pyplot as plt
from pybrain.datasets import ClassificationDataSet
from pybrain.utilities import percentError
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import SoftmaxLayer
from numpy import ravel

Step 2

ขั้นตอนต่อไปคือการสร้าง ClassificationDataSet

สำหรับชุดข้อมูลเราจะใช้ชุดข้อมูลจากชุดข้อมูล sklearn ดังที่แสดงด้านล่าง -

ดูชุดข้อมูล load_digits จาก sklearn ในลิงค์ด้านล่าง -

https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_digits.html#sklearn.datasets.load_digits

digits = datasets.load_digits()
X, y = digits.data, digits.target

ds = ClassificationDataSet(64, 1, nb_classes=10) 
# we are having inputs are 64 dim array and since the digits are from 0-9 the 
classes considered is 10.

for i in range(len(X)):
   ds.addSample(ravel(X[i]), y[i]) # adding sample to datasets

Step 3

แยกชุดข้อมูล 25% เป็นข้อมูลทดสอบและ 75% เป็นข้อมูลที่ฝึกอบรม -

test_data_temp, training_data_temp = ds.splitWithProportion(0.25)

ดังนั้นที่นี่เราได้ใช้วิธีการบนชุดข้อมูลที่เรียกว่า SplitWithProportion () ด้วยค่า 0.25 โดยจะแบ่งชุดข้อมูลออกเป็น 25% เป็นข้อมูลทดสอบและ 75% เป็นข้อมูลการฝึกอบรม

Step 4

การแปลง Testdata และข้อมูลการฝึกอบรมกลับเป็น ClassificationDataSet

test_data = ClassificationDataSet(64, 1, nb_classes=10)
for n in range(0, test_data_temp.getLength()):
   test_data.addSample( test_data_temp.getSample(n)[0], test_data_temp.getSample(n)[1] )
training_data = ClassificationDataSet(64, 1, nb_classes=10)

for n in range(0, training_data_temp.getLength()):

training_data.addSample( 
   training_data_temp.getSample(n)[0], training_data_temp.getSample(n)[1] 
)
test_data._convertToOneOfMany()
training_data._convertToOneOfMany()

การใช้เมธอด splitWithProportion () บนชุดข้อมูลจะแปลงชุดข้อมูลเป็นชุดข้อมูลภายใต้การดูแลดังนั้นเราจะแปลงชุดข้อมูลกลับไปเป็นชุดข้อมูลการจำแนกตามที่แสดงในขั้นตอนข้างต้น

Step 5

ขั้นตอนต่อไปคือการสร้าง Neural Network

net = buildNetwork(training_data.indim, 64, training_data.outdim, outclass=SoftmaxLayer)

เรากำลังสร้างเครือข่ายโดยที่อินพุตและเอาต์พุตจะถูกใช้จากข้อมูลการฝึกอบรม

Step 6

ฝึกอบรมเครือข่าย

ตอนนี้ส่วนที่สำคัญคือการฝึกอบรมเครือข่ายบนชุดข้อมูลดังที่แสดงด้านล่าง -

trainer = BackpropTrainer(net, dataset=training_data, 
momentum=0.1,learningrate=0.01,verbose=True,weightdecay=0.01)

เราใช้วิธี BackpropTrainer () และใช้ชุดข้อมูลบนเครือข่ายที่สร้างขึ้น

Step 7

ขั้นตอนต่อไปคือการแสดงข้อผิดพลาดและการตรวจสอบความถูกต้องของข้อมูล

trnerr,valerr = trainer.trainUntilConvergence(dataset=training_data,maxEpochs=10)
plt.plot(trnerr,'b',valerr,'r')
plt.show()

เราจะใช้วิธีการที่เรียกว่า trainUntilConvergence กับข้อมูลการฝึกอบรมที่จะมาบรรจบกันในยุค 10 ซึ่งจะส่งคืนข้อผิดพลาดในการฝึกอบรมและข้อผิดพลาดในการตรวจสอบความถูกต้องซึ่งเราได้วางแผนไว้ดังที่แสดงด้านล่าง เส้นสีน้ำเงินแสดงข้อผิดพลาดในการฝึกและเส้นสีแดงแสดงข้อผิดพลาดในการตรวจสอบความถูกต้อง

ข้อผิดพลาดทั้งหมดที่ได้รับระหว่างการเรียกใช้โค้ดด้านบนแสดงไว้ด้านล่าง -

Total error: 0.0432857814358
Total error: 0.0222276374185
Total error: 0.0149012052174
Total error: 0.011876985318
Total error: 0.00939854792853
Total error: 0.00782202445183
Total error: 0.00714707652044
Total error: 0.00606068893793
Total error: 0.00544257958975
Total error: 0.00463929281336
Total error: 0.00441275665294
('train-errors:', '[0.043286 , 0.022228 , 0.014901 , 0.011877 , 0.009399 , 0.007
822 , 0.007147 , 0.006061 , 0.005443 , 0.004639 , 0.004413 ]')
('valid-errors:', '[0.074296 , 0.027332 , 0.016461 , 0.014298 , 0.012129 , 0.009
248 , 0.008922 , 0.007917 , 0.006547 , 0.005883 , 0.006572 , 0.005811 ]')

ข้อผิดพลาดเริ่มต้นที่ 0.04 และต่อมาจะลดลงในแต่ละยุคซึ่งหมายความว่าเครือข่ายกำลังได้รับการฝึกอบรมและดีขึ้นสำหรับแต่ละยุค

Step 8

เปอร์เซ็นต์สำหรับข้อผิดพลาดของข้อมูลทดสอบ

เราสามารถตรวจสอบเปอร์เซ็นต์ error โดยใช้วิธี percentError ดังที่แสดงด้านล่าง -

print('Percent Error on 
   testData:',percentError(trainer.testOnClassData(dataset=test_data), 
   test_data['class']))

Percent Error on testData - 3.34075723830735

เราได้รับเปอร์เซ็นต์ความผิดพลาดนั่นคือ 3.34% ซึ่งหมายความว่าเครือข่ายประสาทถูกต้อง 97%

ด้านล่างนี้คือรหัสเต็ม -

from sklearn import datasets
import matplotlib.pyplot as plt
from pybrain.datasets import ClassificationDataSet
from pybrain.utilities import percentError
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.structure.modules import SoftmaxLayer
from numpy import ravel
digits = datasets.load_digits()
X, y = digits.data, digits.target

ds = ClassificationDataSet(64, 1, nb_classes=10)

for i in range(len(X)):
   ds.addSample(ravel(X[i]), y[i])

test_data_temp, training_data_temp = ds.splitWithProportion(0.25)
test_data = ClassificationDataSet(64, 1, nb_classes=10)
for n in range(0, test_data_temp.getLength()):
   test_data.addSample( test_data_temp.getSample(n)[0], test_data_temp.getSample(n)[1] )
training_data = ClassificationDataSet(64, 1, nb_classes=10)

for n in range(0, training_data_temp.getLength()):
   training_data.addSample( 
      training_data_temp.getSample(n)[0], training_data_temp.getSample(n)[1] 
   )
test_data._convertToOneOfMany()
training_data._convertToOneOfMany()

net = buildNetwork(training_data.indim, 64, training_data.outdim, outclass=SoftmaxLayer)
trainer = BackpropTrainer(
   net, dataset=training_data, momentum=0.1,
   learningrate=0.01,verbose=True,weightdecay=0.01
)
trnerr,valerr = trainer.trainUntilConvergence(dataset=training_data,maxEpochs=10)
plt.plot(trnerr,'b',valerr,'r')
plt.show()

trainer.trainEpochs(10)
print('Percent Error on testData:',percentError(
   trainer.testOnClassData(dataset=test_data), test_data['class']
))