TensorFlow ਮਸ਼ੀਨ-ਲਰਨਿੰਗ ਮਾਡਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਬਹੁਮੁਖੀ ਟੂਲ ਹੈ।
ਇਸ ਪੋਸਟ ਵਿੱਚ, ਅਸੀਂ ਦੇਖਾਂਗੇ ਕਿ ਟੈਂਸਰਫਲੋ, ਇੱਕ ਓਪਨ-ਸੋਰਸ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਫਰੇਮਵਰਕ ਨਾਲ ਇੱਕ ਚਿਹਰਾ ਪਛਾਣ ਸਿਸਟਮ ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ। ਅਸੀਂ ਇੱਕ ਸਫਲ ਚਿਹਰਾ ਪਛਾਣ ਪ੍ਰਣਾਲੀ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਪ੍ਰਕਿਰਿਆਵਾਂ 'ਤੇ ਜਾਵਾਂਗੇ, ਡਾਟਾ ਇਕੱਠਾ ਕਰਨ ਅਤੇ ਤਿਆਰ ਕਰਨ ਤੋਂ ਲੈ ਕੇ ਇੱਕ ਮਾਡਲ ਨੂੰ ਸਿਖਲਾਈ ਦੇਣ ਅਤੇ ਮੁਲਾਂਕਣ ਕਰਨ ਤੱਕ।
ਤੁਹਾਨੂੰ ਕੋਡ ਦੇ ਸਨਿੱਪਟਾਂ ਅਤੇ ਅਸਲ-ਸੰਸਾਰ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਦੀ ਸਹਾਇਤਾ ਨਾਲ ਚਿਹਰੇ ਦੀ ਪਛਾਣ ਬਣਾਉਣ ਲਈ TensorFlow ਦੇ ਨਾਲ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਅਨੁਭਵ ਮਿਲੇਗਾ। ਅਸੀਂ ਅੱਗੇ ਵਧਣ ਦੇ ਨਾਲ-ਨਾਲ ਪਾਲਣਾ ਕਰਨ ਲਈ ਤੁਹਾਡਾ ਸੁਆਗਤ ਹੈ।
ਟੈਂਸਰਫਲੋ ਨਾਲ ਜਾਣ-ਪਛਾਣ
TensorFlow ਇੱਕ ਮੁਫਤ ਅਤੇ ਓਪਨ-ਸੋਰਸ ਲਾਇਬ੍ਰੇਰੀ ਹੈ। ਇਹ ਇੱਕ ਪ੍ਰਤੀਕਾਤਮਕ ਗਣਿਤ ਟੂਲਬਾਕਸ ਹੈ ਜੋ ਡੇਟਾਫਲੋ ਅਤੇ ਵਿਭਿੰਨਤਾ ਯੋਗ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ ਇਸਦੇ ਨਾਲ ਬਹੁਤ ਸਾਰੇ ਕੰਮਾਂ ਨੂੰ ਸੰਭਾਲ ਸਕਦੇ ਹੋ, ਜਿਸ ਵਿੱਚ ਡੂੰਘੇ ਵੀ ਸ਼ਾਮਲ ਹਨ ਨਿਊਰਲ ਨੈਟਵਰਕ ਸਿਖਲਾਈ
TensorFlow ਸ਼ਕਤੀਸ਼ਾਲੀ ਅਤੇ ਅਨੁਕੂਲ ਹੈ। ਇਸੇ ਤਰ੍ਹਾਂ, ਇਹ ਵਿਕਾਸ ਲਈ ਇੱਕ ਵਧੀਆ ਸਾਧਨ ਹੈ ਅਤੇ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਮਾਡਲਾਂ ਨੂੰ ਤੈਨਾਤ ਕਰਨਾ. ਤੁਸੀਂ ਕਈ ਲੇਅਰਾਂ ਅਤੇ ਟੈਂਸਰ ਓਪਰੇਸ਼ਨਾਂ ਨਾਲ ਗੁੰਝਲਦਾਰ ਮਾਡਲ ਬਣਾ ਸਕਦੇ ਹੋ। ਨਾਲ ਹੀ, ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਪਹਿਲਾਂ ਤੋਂ ਬਣੇ ਮਾਡਲਾਂ ਨੂੰ ਖਾਸ ਲੋੜਾਂ ਲਈ ਵਧੀਆ ਬਣਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।
ਇਸ ਤੋਂ ਇਲਾਵਾ, TensorFlow ਦਾ ਇੱਕ ਵਿਸ਼ਾਲ ਅਤੇ ਵਿਸਤ੍ਰਿਤ ਉਪਭੋਗਤਾ ਭਾਈਚਾਰਾ ਹੈ। ਇਸ ਲਈ, ਪਲੇਟਫਾਰਮ ਲਈ ਨਵੇਂ ਵਿਅਕਤੀਆਂ ਲਈ ਜਾਣਕਾਰੀ ਅਤੇ ਮਦਦ ਦੀ ਬਹੁਤਾਤ ਹੈ।
TensorFlow ਲਈ ਪ੍ਰਸਿੱਧ ਹੈ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਅੰਸ਼ਕ ਰੂਪ ਵਿੱਚ ਕਿਉਂਕਿ ਇਹ ਇੱਕ ਅੰਤ ਤੋਂ ਅੰਤ ਤੱਕ ਵਰਕਫਲੋ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਇਸ ਲਈ, ਤੁਸੀਂ ਆਸਾਨੀ ਨਾਲ ਮਾਡਲਾਂ ਦਾ ਨਿਰਮਾਣ, ਸਿਖਲਾਈ ਅਤੇ ਤੈਨਾਤ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਖਾਸ ਮੰਗਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਮਾਡਲਾਂ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਣ ਅਤੇ ਸਕੇਲਿੰਗ ਕਰਨ ਲਈ ਟੂਲ ਅਤੇ ਰਣਨੀਤੀਆਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਇਹ ਡਾਟਾ ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸਿੰਗ ਤੋਂ ਲੈ ਕੇ ਮਾਡਲ ਡਿਪਲਾਇਮੈਂਟ ਤੱਕ ਵੱਖਰਾ ਹੁੰਦਾ ਹੈ।
ਚਿਹਰਾ ਪਛਾਣ ਕੀ ਹੈ?
ਚਿਹਰੇ ਦੀ ਪਛਾਣ ਏ ਕੰਪਿਊਟਰ ਦ੍ਰਿਸ਼ਟੀ ਉਹ ਕੰਮ ਜੋ ਕਿਸੇ ਵਿਅਕਤੀ ਦੀ ਪਛਾਣ ਉਸਦੇ ਚਿਹਰੇ ਦੇ ਆਧਾਰ 'ਤੇ ਕਰਦਾ ਹੈ। ਇਹ ਤਕਨੀਕ ਚਿਹਰੇ ਦੇ ਲੱਛਣਾਂ ਨੂੰ ਪਛਾਣਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਅੱਖਾਂ, ਨੱਕ ਅਤੇ ਮੂੰਹ ਦੀ ਸ਼ਕਲ ਅਤੇ ਬਣਤਰ।
ਅਤੇ, ਇਹ ਮੈਚ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਉਹਨਾਂ ਦੀ ਤੁਲਨਾ ਜਾਣੇ-ਪਛਾਣੇ ਚਿਹਰਿਆਂ ਦੇ ਡੇਟਾਬੇਸ ਨਾਲ ਕਰਦਾ ਹੈ। ਚਿਹਰੇ ਦੀ ਪਛਾਣ ਦੇ ਕਈ ਉਪਯੋਗ ਹਨ, ਜਿਸ ਵਿੱਚ ਸੁਰੱਖਿਆ ਪ੍ਰਣਾਲੀਆਂ, ਫੋਟੋ ਸੰਗਠਨ, ਅਤੇ ਬਾਇਓਮੈਟ੍ਰਿਕ ਪ੍ਰਮਾਣਿਕਤਾ ਸ਼ਾਮਲ ਹਨ।
ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਵਿੱਚ ਸਫਲਤਾਵਾਂ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਹਾਲ ਹੀ ਦੇ ਸਾਲਾਂ ਵਿੱਚ ਚਿਹਰੇ ਦੀ ਪਛਾਣ ਕਰਨ ਵਾਲੇ ਐਲਗੋਰਿਦਮ ਦੀ ਸ਼ੁੱਧਤਾ ਵਿੱਚ ਕਾਫ਼ੀ ਵਾਧਾ ਹੋਇਆ ਹੈ।
ਜ਼ਰੂਰੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਆਯਾਤ ਕਰਨਾ
ਕੁਝ ਵੀ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਸਾਨੂੰ ਆਪਣੇ ਮਾਡਲ ਲਈ ਲੋੜੀਂਦੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਆਯਾਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਟੈਨਸਰਫਲੋ (tf) ਨੂੰ ਆਯਾਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮਾਡਲ ਬਣਾਉਣ ਅਤੇ ਸਿਖਲਾਈ ਦੇਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। <(p>
"ਨੰਪੀ" ਗਣਿਤਿਕ ਗਣਨਾਵਾਂ ਅਤੇ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਕਰਦਾ ਹੈ।
"matplotlib.pyplot" ਨੂੰ plt ਦੇ ਰੂਪ ਵਿੱਚ ਆਯਾਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਸਦੇ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਡਾਟਾ ਚਾਰਟਿੰਗ ਅਤੇ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ.
ਅੰਤ ਵਿੱਚ, "ftch lfw people" ਨੂੰ sklearn ਤੋਂ ਆਯਾਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਡੇਟਾਸੈੱਟ ਅਤੇ ਚਿਹਰੇ ਦੀ ਪਛਾਣ ਡੇਟਾਸੈਟ ਨੂੰ ਲੋਡ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਫੰਕਸ਼ਨ ਸਕਿਟ-ਲਰਨ ਟੂਲਕਿੱਟ ਦਾ ਹਿੱਸਾ ਹੈ। ਇਸ ਫੰਕਸ਼ਨ ਲਈ ਧੰਨਵਾਦ ਸਾਨੂੰ ਕੋਈ ਹੋਰ ਡੇਟਾਸੈਟ ਅੱਪਲੋਡ ਨਹੀਂ ਕਰਨਾ ਪਿਆ। ਇਹ ਪਹਿਲਾਂ ਹੀ ਸਕਿਟ-ਲਰਨ ਵਿੱਚ ਬਣਾਇਆ ਗਿਆ ਹੈ।
ਅਤੇ, ਇਹ ਤੁਹਾਨੂੰ ਦੀ ਇੱਕ ਵਿਸ਼ਾਲ ਸ਼੍ਰੇਣੀ ਤੱਕ ਪਹੁੰਚ ਦਿੰਦਾ ਹੈ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਲਈ ਡਾਟਾਸੈੱਟ ਐਪਲੀਕੇਸ਼ਨਾਂ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਅਸੀਂ "ਲੇਬਲ ਕੀਤੇ ਫੇਸ ਇਨ ਦ ਵਾਈਲਡ" (LFW) ਡੇਟਾਸੈਟ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ lftch lfw People ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਇਸ ਵਿੱਚ ਲੋਕਾਂ ਦੇ ਚਿਹਰਿਆਂ ਦੀਆਂ ਫੋਟੋਆਂ ਦੇ ਨਾਲ-ਨਾਲ ਉਹਨਾਂ ਦੇ ਨਾਲ ਜਾਣ ਵਾਲੇ ਲੇਬਲ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ।
ਇਹ ਲਾਇਬ੍ਰੇਰੀਆਂ ਸਾਡੇ ਚਿਹਰਾ ਪਛਾਣ ਮਾਡਲ ਨੂੰ ਲਾਗੂ ਕਰਨ ਅਤੇ ਮੁਲਾਂਕਣ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਹਨ।
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
ਫੇਸ ਰੀਕੋਗਨੀਸ਼ਨ ਡੇਟਾਸੈਟ ਨੂੰ ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸਿੰਗ ਅਤੇ ਲੋਡ ਕਰਨਾ
ਇਸ ਹਿੱਸੇ ਵਿੱਚ, ਅਸੀਂ ਚਿਹਰੇ ਦੀ ਪਛਾਣ ਡੇਟਾ ਨੂੰ ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸ ਕਰਨ ਲਈ "ftch lfw people" ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਪਹਿਲਾਂ, ਅਸੀਂ "min faces per person=60" ਵਿਕਲਪ ਦੇ ਨਾਲ lfw people ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਅਸੀਂ ਡੇਟਾਸੈਟ ਵਿੱਚ ਸਿਰਫ ਉਹਨਾਂ ਵਿਅਕਤੀਆਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ ਜਿਨ੍ਹਾਂ ਕੋਲ ਘੱਟੋ-ਘੱਟ 60 ਫੋਟੋਆਂ ਹਨ। ਇਸ ਲਈ, ਅਸੀਂ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹਾਂ ਕਿ ਸਾਡੇ ਮਾਡਲ ਵਿੱਚ ਸਿੱਖਣ ਲਈ ਢੁਕਵਾਂ ਡੇਟਾ ਹੈ। ਨਾਲ ਹੀ, ਇਹ ਓਵਰਫਿਟਿੰਗ ਦੇ ਖ਼ਤਰੇ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ।
ਫੇਸ ਆਬਜੈਕਟ ਤੋਂ ਡੇਟਾ ਅਤੇ ਲੇਬਲ ਫਿਰ ਐਕਸਟਰੈਕਟ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਵੇਰੀਏਬਲ X ਅਤੇ y ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਐਕਸ ਹੋਲ.
ਅਸੀਂ ਹੁਣ ਪ੍ਰੀ-ਪ੍ਰੋਸੈੱਸਡ ਡੇਟਾ ਅਤੇ ਲੇਬਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੇ ਚਿਹਰੇ ਦੀ ਪਛਾਣ ਮਾਡਲ ਨੂੰ ਸਿਖਲਾਈ ਦੇਣ ਲਈ ਤਿਆਰ ਹਾਂ।
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
ਵੰਡਣ ਦੀ ਸਿਖਲਾਈ ਅਤੇ ਟੈਸਟ ਸੈੱਟ
ਇਸ ਪੜਾਅ ਵਿੱਚ, ਅਸੀਂ sklearn.model ਚੋਣ ਤੋਂ ਟ੍ਰੇਨ ਟੈਸਟ ਸਪਲਿਟ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਆਪਣੇ ਚਿਹਰਾ ਪਛਾਣ ਡੇਟਾਸੈਟ ਨੂੰ ਦੋ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਹੈ। ਇਸ ਵੰਡ ਦਾ ਟੀਚਾ ਸਿਖਲਾਈ ਤੋਂ ਬਾਅਦ ਸਾਡੇ ਮਾਡਲ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨਾ ਹੈ
ਟ੍ਰੇਨ ਟੈਸਟ ਸਪਲਿਟ ਫੰਕਸ਼ਨ ਇਨਪੁਟਸ ਡੇਟਾ X ਅਤੇ ਲੇਬਲ y ਦੇ ਤੌਰ ਤੇ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ। ਅਤੇ, ਇਹ ਉਹਨਾਂ ਨੂੰ ਸਿਖਲਾਈ ਅਤੇ ਟੈਸਟ ਸੈੱਟਾਂ ਵਿੱਚ ਵੰਡਦਾ ਹੈ. ਅਸੀਂ ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਟੈਸਟ ਦਾ ਆਕਾਰ = 0.2 ਚੁਣਦੇ ਹਾਂ। ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ 20% ਡੇਟਾ ਟੈਸਟ ਸੈੱਟ ਅਤੇ 80% ਸਿਖਲਾਈ ਸੈੱਟ ਦੇ ਤੌਰ 'ਤੇ ਵਰਤਿਆ ਜਾਵੇਗਾ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਅਸੀਂ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਬੇਤਰਤੀਬ ਅਵਸਥਾ=42 ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਕਿ ਜਦੋਂ ਵੀ ਕੋਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਡੇਟਾ ਨੂੰ ਲਗਾਤਾਰ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ।
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
ਡਾਟਾ ਤਿਆਰ ਕਰ ਰਿਹਾ ਹੈ
ਪੂਰਵ-ਪ੍ਰੋਸੈਸਿੰਗ ਡੇਟਾ ਦਾ ਉਦੇਸ਼ ਇਸ ਨੂੰ ਮਾਡਲ ਵਿੱਚ ਦਾਖਲੇ ਲਈ ਤਿਆਰ ਕਰਨਾ ਹੈ। ਹਰੇਕ ਡੇਟਾ ਪੁਆਇੰਟ ਨੂੰ 255 ਨਾਲ ਵੰਡ ਕੇ ਇਸ ਕੋਡ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਪਹਿਲਾਂ ਤੋਂ ਪ੍ਰੋਸੈਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
ਸਾਨੂੰ ਇਹ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਕਿਸ ਚੀਜ਼ ਨੇ ਪ੍ਰੇਰਿਤ ਕੀਤਾ? ਸਧਾਰਣਕਰਨ ਇੱਕ ਪ੍ਰੀਪ੍ਰੋਸੈਸਿੰਗ ਪ੍ਰਕਿਰਿਆ ਹੈ ਜੋ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਵਿੱਚ ਇਸ ਗੱਲ ਦੀ ਗਾਰੰਟੀ ਦੇਣ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਸਾਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਇੱਕੋ ਪੈਮਾਨੇ 'ਤੇ ਹਨ। ਇਸ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਵਿੱਚ, 255 ਦੁਆਰਾ ਵੰਡਣਾ ਡੇਟਾ ਨੂੰ 0 ਤੋਂ 1 ਦੀ ਰੇਂਜ ਵਿੱਚ ਸਕੇਲ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਆਮ ਤਸਵੀਰ ਡੇਟਾ ਸਧਾਰਣਕਰਨ ਪੜਾਅ ਹੈ।
ਇਹ ਮਾਡਲ ਦੇ ਕਨਵਰਜੈਂਸ ਨੂੰ ਤੇਜ਼ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਦੇ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਵਧਾ ਸਕਦਾ ਹੈ।
X_train = X_train / 255.0
X_test = X_test / 255.0
ਮੋਡ ਬਣਾਉਣਾ
ਅਸੀਂ ਉਸ ਵਿਅਕਤੀ ਦੀ ਪਛਾਣ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ ਜਿਸਦਾ ਚਿਹਰਾ ਤਸਵੀਰ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਾਲ ਜੁੜੇ ਨੈੱਟਵਰਕ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ, ਜਿਸਨੂੰ ਅਕਸਰ ਇੱਕ ਸੰਘਣੇ ਨੈੱਟਵਰਕ ਵਜੋਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਇੱਕ ਨਕਲੀ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਹੈ ਜੋ ਮਾਡਲ ਬਣਾਉਣ ਲਈ ਵਰਤਿਆ ਗਿਆ ਸੀ।
ਨਕਲੀ ਤੰਤੂ ਨੈੱਟਵਰਕ ਨੂੰ ਮਨੁੱਖੀ ਦਿਮਾਗ ਦੇ ਕੰਮ ਕਰਨ ਅਤੇ ਸੰਗਠਿਤ ਕੀਤੇ ਜਾਣ ਦੇ ਬਾਅਦ ਮਾਡਲ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਉਹ ਜਾਣਕਾਰੀ-ਪ੍ਰੋਸੈਸਿੰਗ ਨੋਡਸ ਜਾਂ ਨਿਊਰੋਨਸ ਦੇ ਬਣੇ ਹੁੰਦੇ ਹਨ ਜੋ ਜੁੜੇ ਹੁੰਦੇ ਹਨ। ਸੰਘਣੀ ਨੈੱਟਵਰਕ ਵਿੱਚ ਇੱਕ ਪਰਤ ਵਿੱਚ ਹਰੇਕ ਨਿਊਰੋਨ ਇਸਦੇ ਉੱਪਰਲੀ ਪਰਤ ਵਿੱਚ ਹਰ ਨਿਊਰੋਨ ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ।
ਇਸ ਕੋਡ ਵਿੱਚ ਮਾਡਲ ਦੀਆਂ ਚਾਰ ਪਰਤਾਂ ਹਨ। ਅਗਲੀ ਲੇਅਰ ਵਿੱਚ ਫੀਡ ਕਰਨ ਲਈ, ਇਨਪੁਟ ਡੇਟਾ ਨੂੰ ਪਹਿਲੀ ਪਰਤ ਵਿੱਚ ਇੱਕ-ਅਯਾਮੀ ਐਰੇ ਵਿੱਚ ਸਮਤਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਹੇਠ ਲਿਖੀਆਂ ਦੋ ਪਰਤਾਂ ਵਿੱਚ 128 ਅਤੇ 64 ਨਿਊਰੋਨ, ਇਸ ਅਨੁਸਾਰ, ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਾਲ ਜੁੜੇ ਹੋਏ ਹਨ।
ReLU ਐਕਟੀਵੇਸ਼ਨ ਫੰਕਸ਼ਨ ਇੱਕ ਵਿਲੱਖਣ ਐਕਟੀਵੇਸ਼ਨ ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਇਹਨਾਂ ਲੇਅਰਾਂ ਦੁਆਰਾ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਸਦੇ ਨਾਲ, ਅਸੀਂ ਇਨਪੁਟਸ ਅਤੇ ਆਉਟਪੁੱਟ ਦੇ ਵਿਚਕਾਰ ਗੈਰ-ਲੀਨੀਅਰ ਸਬੰਧਾਂ ਨੂੰ ਸਿੱਖਣ ਲਈ ਮਾਡਲ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ। ਆਖਰੀ ਪਰਤ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਲਈ ਸਾਫਟਮੈਕਸ ਐਕਟੀਵੇਸ਼ਨ ਫੰਕਸ਼ਨ ਨੂੰ ਨਿਯੁਕਤ ਕਰਦੀ ਹੈ। ਅਤੇ, ਇਹ ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਜੁੜੀ ਪਰਤ ਹੈ ਜਿਸ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਨਿਊਰੋਨਸ ਹਨ ਜਿੰਨਾ ਸੰਭਾਵੀ ਕਲਾਸਾਂ ਹਨ।
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(62 * 47,)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(len(target_names), activation='softmax')
])
ਮਾਡਲ ਦਾ ਸੰਕਲਨ
ਮਾਡਲ ਨੂੰ "ਕੰਪਾਇਲ" ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੰਪਾਇਲ ਕੀਤਾ ਗਿਆ ਹੈ। ਸਾਨੂੰ ਸਿਖਲਾਈ ਲਈ ਮਾਡਲ ਤਿਆਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਲਈ, ਅਸੀਂ ਆਪਟੀਮਾਈਜ਼ਰ, ਨੁਕਸਾਨ ਫੰਕਸ਼ਨ, ਅਤੇ ਮੈਟ੍ਰਿਕਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਾਂਗੇ ਜੋ ਮਾਡਲ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ ਵਰਤੇ ਜਾਣਗੇ।
ਸਿਖਲਾਈ ਦੌਰਾਨ, ਆਪਟੀਮਾਈਜ਼ਰ ਮਾਡਲ ਦੇ ਮਾਪਦੰਡਾਂ ਨੂੰ ਬਦਲਣ ਦਾ ਇੰਚਾਰਜ ਹੁੰਦਾ ਹੈ। "ਐਡਮ" ਆਪਟੀਮਾਈਜ਼ਰ ਇੱਕ ਪ੍ਰਸਿੱਧ ਡੂੰਘੀ-ਸਿਖਲਾਈ ਅਨੁਕੂਲਨ ਤਕਨੀਕ ਹੈ।
ਅਸੀਂ ਸਿਖਲਾਈ ਡੇਟਾ 'ਤੇ ਮਾਡਲ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ ਨੁਕਸਾਨ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਕਿਉਂਕਿ ਟਾਰਗੇਟ ਲੇਬਲ ਇੱਕ-ਹੌਟ ਏਨਕੋਡਡ ਵੈਕਟਰਾਂ ਦੀ ਬਜਾਏ ਚਿੱਤਰ ਦੀ ਸ਼੍ਰੇਣੀ ਨੂੰ ਦਰਸਾਉਂਦੇ ਪੂਰਨ ਅੰਕ ਹਨ, "ਸਪਾਰਸ ਕੈਟੇਗਰੀਕਲ ਕ੍ਰਾਸੈਂਟ੍ਰੋਪੀ" ਨੁਕਸਾਨ ਫੰਕਸ਼ਨ ਅਨੁਕੂਲ ਹੈ।
ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਮਾਡਲ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ ਮੈਟ੍ਰਿਕਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹਾਂ, ਇਸ ਕੇਸ ਵਿੱਚ, "ਸ਼ੁੱਧਤਾ"।
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
ਮਾਡਲ ਸਿਖਲਾਈ
ਅਸੀਂ ਮਾਡਲ ਨੂੰ ਸਿਖਲਾਈ ਦੇਣ ਲਈ "ਫਿੱਟ" ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ।
ਅਸੀਂ ਸਿਖਲਾਈ ਡੇਟਾ (X ਟ੍ਰੇਨ) ਅਤੇ ਸੰਬੰਧਿਤ ਲੇਬਲ (y ਟ੍ਰੇਨ) ਪ੍ਰਦਾਨ ਕਰਾਂਗੇ, ਨਾਲ ਹੀ 10 ਦੇ ਤੌਰ 'ਤੇ ਚੱਲਣ ਲਈ ਯੁੱਗਾਂ (ਦੁਹਰਾਓ) ਦੀ ਸੰਖਿਆ ਨੂੰ ਸੈੱਟ ਕਰਾਂਗੇ। ਸਿਖਲਾਈ ਪ੍ਰਕਿਰਿਆ ਨੁਕਸਾਨ ਨੂੰ ਘਟਾਉਣ ਲਈ ਮਾਡਲ ਵਜ਼ਨ ਨੂੰ ਸੋਧਦੀ ਹੈ (ਵਿਚਕਾਰ ਅੰਤਰ ਪੂਰਵ-ਅਨੁਮਾਨਿਤ ਅਤੇ ਅਸਲ ਲੇਬਲ) ਅਤੇ ਸਿਖਲਾਈ ਡੇਟਾ ਦੀ ਸ਼ੁੱਧਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰੋ।
model.fit(X_train, y_train, epochs=10)
ਮਾਡਲ ਮੁਲਾਂਕਣ
ਹੁਣ, ਸਾਨੂੰ ਟੈਸਟ ਡੇਟਾ 'ਤੇ ਸਿਖਲਾਈ ਪ੍ਰਾਪਤ ਮਾਡਲ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਅਸੀਂ ਟੈਸਟ ਦੇ ਨੁਕਸਾਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਅਤੇ ਟੈਸਟ ਦੀ ਸ਼ੁੱਧਤਾ ਦੀ ਵਰਤੋਂ ਮਾਡਲ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਟੈਸਟ ਡੇਟਾ X ਟੈਸਟ ਅਤੇ ਟੈਸਟ ਲੇਬਲ y ਟੈਸਟ 'ਤੇ, ਸਾਨੂੰ "model.evaluate ਫੰਕਸ਼ਨ" ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।
ਫੰਕਸ਼ਨ ਟੈਸਟ ਦੀ ਸ਼ੁੱਧਤਾ ਅਤੇ ਟੈਸਟ ਦੇ ਨੁਕਸਾਨ ਨੂੰ ਆਊਟਪੁੱਟ ਕਰਦਾ ਹੈ। ਵੇਰੀਏਬਲ ਟੈਸਟ ਹਾਰਨ ਅਤੇ ਟੈਸਟ ਸ਼ੁੱਧਤਾ, ਕ੍ਰਮਵਾਰ, ਇਹ ਮੁੱਲ ਰੱਖਦੇ ਹਨ। ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਟੈਸਟ ਦੀ ਸ਼ੁੱਧਤਾ ਨੂੰ ਆਉਟਪੁੱਟ ਕਰਨ ਲਈ "ਪ੍ਰਿੰਟ" ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
ਕਲਾਸਾਂ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਨਾ ਅਤੇ ਅਨੁਮਾਨਿਤ ਕਲਾਸਾਂ ਪ੍ਰਾਪਤ ਕਰਨਾ
ਸਿਖਲਾਈ ਮਾਡਲ ਅਤੇ ਟੈਸਟ ਡੇਟਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਐਲਗੋਰਿਦਮ ਭਵਿੱਖਬਾਣੀ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਟੈਸਟ ਡੇਟਾ ਨੂੰ "model.predict" ਵਿਧੀ ਵਿੱਚ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਟੈਸਟ ਸੈੱਟ ਵਿੱਚ ਹਰੇਕ ਤਸਵੀਰ ਲਈ ਪੂਰਵ-ਅਨੁਮਾਨਾਂ ਦੀ ਇੱਕ ਲੜੀ ਨੂੰ ਆਊਟਪੁੱਟ ਕਰਦਾ ਹੈ।
ਹਰੇਕ ਤਸਵੀਰ ਲਈ ਟਾਰਗੇਟ ਕਲਾਸ ਦਾ ਨਾਮ ਫਿਰ "np.argmax" ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ "ਟਾਰਗੇਟ ਨਾਮ" ਸੂਚੀ ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ ਸਭ ਤੋਂ ਵੱਧ ਅਨੁਮਾਨਿਤ ਸੰਭਾਵਨਾ ਦੇ ਨਾਲ ਸੂਚਕਾਂਕ ਦੀ ਪਛਾਣ ਕੀਤੀ ਜਾ ਸਕੇ। ਇਹ ਸੂਚਕਾਂਕ ਫਿਰ ਹਰੇਕ ਚਿੱਤਰ ਲਈ ਪੂਰਵ ਅਨੁਮਾਨਿਤ ਸ਼੍ਰੇਣੀ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
ਇੱਕ ਸੂਚੀ ਸਮਝ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, "ਭਵਿੱਖਬਾਣੀ" ਐਰੇ ਵਿੱਚ ਸਾਰੀਆਂ ਭਵਿੱਖਬਾਣੀਆਂ ਇਸ ਵਿਧੀ ਦੇ ਅਧੀਨ ਹੁੰਦੀਆਂ ਹਨ, ਨਤੀਜੇ ਵਜੋਂ "ਅਨੁਮਾਨਿਤ ਕਲਾਸਾਂ" ਸੂਚੀ ਹੁੰਦੀ ਹੈ।
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
ਭਵਿੱਖਬਾਣੀਆਂ ਦੀ ਕਲਪਨਾ ਕਰਨਾ
ਅਸੀਂ ਹੁਣ ਦੇਖ ਸਕਦੇ ਹਾਂ ਕਿ ਸਾਡਾ ਮਾਡਲ ਕਿਵੇਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ।
ਇਹ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ ਕਿ ਮਾਡਲ ਕਿੰਨੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ, ਪਹਿਲੀਆਂ 10 ਫੋਟੋਆਂ ਅਤੇ ਉਹਨਾਂ ਦੀਆਂ ਭਵਿੱਖਬਾਣੀਆਂ ਦਿਖਾਈਆਂ ਜਾਣਗੀਆਂ। ਇਹ ਫੋਟੋਆਂ ਨੂੰ ਗ੍ਰੇਸਕੇਲ ਵਿੱਚ ਪਲਾਟ ਕਰੇਗਾ ਅਤੇ matplotlib.pyplot ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਚਿੱਤਰ ਦੀ ਅਸਲ ਸ਼੍ਰੇਣੀ ਅਤੇ ਮਾਡਲ ਦੁਆਰਾ ਭਵਿੱਖਬਾਣੀ ਕੀਤੀ ਕਲਾਸ ਦੋਵਾਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੇਗਾ।
"imshow" ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਲੂਪ ਦੁਆਰਾ ਪਹਿਲੀਆਂ 10 ਟੈਸਟ ਸੈਟ ਫੋਟੋਆਂ ਵਿੱਚੋਂ ਹਰੇਕ ਨੂੰ ਪਲਾਟ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਨਿਸ਼ਾਨਾ ਨਾਮ[y ਟੈਸਟ[i]] ਅਤੇ ਪੂਰਵ-ਅਨੁਮਾਨਿਤ ਕਲਾਸਾਂ[i] ਦੀ ਵਰਤੋਂ ਕ੍ਰਮਵਾਰ ਚਿੱਤਰ ਦੀ ਅਸਲ ਸ਼੍ਰੇਣੀ ਅਤੇ ਪੂਰਵ ਅਨੁਮਾਨਿਤ ਸ਼੍ਰੇਣੀ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਹਰੇਕ ਪਲਾਟ ਦੇ ਸਿਰਲੇਖ ਫਿਰ ਇਹਨਾਂ ਵਰਗੀਕਰਨਾਂ ਦੁਆਰਾ ਦਰਸਾਏ ਜਾਂਦੇ ਹਨ।
ਅੰਤ ਵਿੱਚ, ਪਲਾਟ plt.show() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪ੍ਰਦਰਸ਼ਿਤ ਹੁੰਦਾ ਹੈ।
for i in range(10):
plt.imshow(X_test[i].reshape(62, 47), cmap='gray')
plt.title(f"True: {target_names[y_test[i]]}, Predicted:{predicted_classes[i]}")
plt.show()
ਸਮੇਟੋ ਉੱਪਰ
TensorFlow ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਸੰਪੂਰਨ ਅਤੇ ਲਚਕਦਾਰ ਵਾਤਾਵਰਣ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ।
ਵਿਸ਼ੇਸ਼ ਲੋੜਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਮਾਡਲ ਨੂੰ ਵਧੀਆ-ਟਿਊਨਿੰਗ ਕਰਕੇ ਜਾਂ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਵਿੱਚ ਨਵੇਂ ਵਿਕਾਸ ਨੂੰ ਜੋੜ ਕੇ, ਮਾਡਲ ਦੀ ਸ਼ੁੱਧਤਾ ਨੂੰ ਹੋਰ ਵੀ ਵਧਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।
TensorFlow ਅਤੇ ਚਿਹਰੇ ਦੀ ਪਛਾਣ ਭਵਿੱਖ ਵਿੱਚ ਸੁਰੱਖਿਆ ਪ੍ਰਣਾਲੀਆਂ, ਬਾਇਓਮੀਟ੍ਰਿਕ ਪ੍ਰਮਾਣੀਕਰਨ, ਅਤੇ ਸਿਹਤ ਸੰਭਾਲ ਵਰਗੇ ਉਦਯੋਗਾਂ ਵਿੱਚ ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ ਤੇਜ਼ੀ ਨਾਲ ਵਰਤੀ ਜਾਵੇਗੀ। ਅਸੀਂ ਜਲਦੀ ਹੀ ਦਿਲਚਸਪ ਕਾਢਾਂ ਨੂੰ ਦੇਖਾਂਗੇ।
ਕੋਈ ਜਵਾਬ ਛੱਡਣਾ