ٹینسر فلو کے ساتھ درجہ بندی کے لیے اعصابی نیٹ ورک

اس مضمون کے ایک حصے کے طور پر شائع کیا گیا تھا۔ ڈیٹا سائنس بلاگتھون

اس مضمون میں، میں درجہ بندی کے مسئلے کو حل کرنے کے لیے TensorFlow کے ساتھ نیورل نیٹ ورک ماڈل بنانے جا رہا ہوں۔ آئیے مل کر دریافت کریں کہ ہم Tensorflow میں درجہ بندی کے مسئلے سے کیسے رجوع کر سکتے ہیں۔ لیکن سب سے پہلے، میں یہ یقینی بنانا چاہوں گا کہ ہم ان سوالوں کے جواب دینے کے قابل ہیں:

اعصابی نیٹ ورک ہے؟

نیورل نیٹ ورک کا بنیادی مقصد ڈیٹا سیٹ میں موجود خصوصیات کے درمیان تعلق تلاش کرنے کی کوشش کرنا ہے۔، اور یہ الگورتھم کے ایک سیٹ پر مشتمل ہوتا ہے جو انسانی دماغ کے کام کی نقل کرتا ہے۔ نیورل نیٹ ورک میں ایک "نیورون" ایک ریاضیاتی فنکشن ہے جو ایک مخصوص فن تعمیر کے مطابق معلومات کو جمع اور درجہ بندی کرتا ہے۔

درجہ بندی کیا ہے؟

درجہ بندی کے مسئلے میں یہ پیش گوئی کرنا شامل ہے کہ آیا کوئی چیز ایک طبقے سے تعلق رکھتی ہے یا نہیں۔ دوسرے لفظوں میں، یہ کرتے وقت ہم یہ دیکھنے کی کوشش کرتے ہیں کہ کوئی چیز ایک یا دوسری چیز ہے۔

درجہ بندی کی اقسام

• فرض کریں کہ آپ اندازہ لگانا چاہتے ہیں کہ آیا کسی شخص کو ذیابیطس ہے یا نہیں۔ اگر آپ کو اس قسم کی صورتحال کا سامنا ہے، تو دو امکانات ہیں، ٹھیک ہے؟ اسے کہتے ہیں۔ بائنری درجہ بندی۔
• فرض کریں کہ آپ یہ شناخت کرنا چاہتے ہیں کہ کیا کوئی تصویر کھلونا، کسی شخص یا بلی کی ہے، ٹھیک ہے؟ یہ کہا جاتا ہے ملٹی کلاس کی درجہ بندی کیونکہ دو سے زیادہ آپشنز ہیں۔
• فرض کریں کہ آپ یہ فیصلہ کرنا چاہتے ہیں کہ مضمون کو کون سے زمرے تفویض کیے جائیں۔ اگر ایسا ہے تو اسے کہا جاتا ہے۔ ملٹی لیبل کی درجہ بندیکیونکہ ایک مضمون کو ایک سے زیادہ زمرہ تفویض کیا جا سکتا ہے۔ آئیے اس مضمون کے ذریعے اپنی وضاحت لیتے ہیں۔ ہم اس مضمون کو "ڈیپ لرننگ، ٹینسر فلو، درجہ بندی" وغیرہ جیسے زمرے تفویض کر سکتے ہیں۔

اب ہم آگے بڑھ سکتے ہیں کیونکہ ہمیں اس مسئلے کی مشترکہ سمجھ ہے جس پر ہم کام کریں گے۔ لہذا، یہ کوڈنگ کا وقت ہے. مجھے امید ہے کہ آپ انہیں میرے ساتھ لکھ رہے ہوں گے کیونکہ بہتر ہونے کا واحد طریقہ، کم غلطیاں کرنا زیادہ کوڈ لکھنا ہے۔

ہم لائبریریوں کو درآمد کرنے کے ساتھ شروع کر رہے ہیں جو ہم استعمال کریں گے:

numpy درآمد کریں بطور np درآمد پانڈاس pd درآمد کریں matplotlib.pyplot بطور plt درآمد کریں ٹینسر فلو بطور tf پرنٹ(tf.__version__)

ڈیٹاسیٹ بنانا

یہ کام کرنے کے لیے ڈیٹاسیٹ بنانے کا وقت ہے:

sklearn.datasets سے make_circles کے نمونے = 1000 X، y = make_circles (نمونے، شور = 0.03، random_state = 42) درآمد کریں

پرنٹ(X>> 0.75424625] [ 0.23148074 0.75615888]]

پرنٹ(y) >> [1 1 1 1 0 1 1 1 1 0]

ٹھیک ہے، ہم نے اپنے ڈیٹاسیٹ کو مزید تفصیل سے دیکھا ہے، لیکن ہم ابھی تک اس کے بارے میں کچھ نہیں جانتے، ٹھیک ہے؟ یہی وجہ ہے کہ یہاں ایک اہم قدم ڈیٹا کے ساتھ ایک ہونا ہے، اور اس کے لیے تصور بہترین طریقہ ہے۔

دائرہ = pd.DataFrame({ 'X0' : X[:, 0], 'X1' : X[:, 1], 'label' : y}) circle.head()

یہاں ایک سوال یہ پیدا ہوتا ہے کہ ہم کس قسم کے لیبلوں سے نمٹ رہے ہیں؟

circle.label.value_counts() >> 1 500 0 500 نام: لیبل، dtype: int64

ایسا لگتا ہے کہ ہم اس سے نمٹ رہے ہیں۔ بائنری درجہ بندی کا مسئلہکیونکہ ہمارے پاس 2 لیبل (0 اور 1) ہیں۔

plt.scatter(X[:,0], X[:,1], c = y, cmap = plt.cm.RdYlBu)

جیسا کہ میں نے اوپر ذکر کیا ہے، ڈیٹا کے ساتھ حاصل کرنے کا بہترین طریقہ تصور ہے۔ اب پلاٹ خود کہتا ہے کہ ہمیں کس قسم کا ماڈل بنانے کی ضرورت ہے۔ ہم ایک ایسا ماڈل بنائیں گے جو نیلے نقطوں کو سرخ نقطوں سے ممتاز کرنے کے قابل ہو۔

کسی بھی نیورل نیٹ ورک ماڈل کو بنانے سے پہلے، ہمیں اپنے ان پٹ اور آؤٹ پٹ فیچرز کی شکلوں کو چیک کرنا چاہیے۔ وہ ایک ہی ہونا چاہئے!

پرنٹ(X.shape, y.shape) print(len(X), len(y)) >> (1000, 2) (1000,) 1000 1000

ہمارے پاس ہر خصوصیت کے لئے قدروں کی ایک ہی مقدار ہے، لیکن X کی شکل مختلف ہے؟ کیوں؟ آئیے اسے چیک کریں۔

X[0]، y[0] >> (ارے([0.75424625, 0.23148074])، 1)

ٹھیک ہے، ہمارے پاس 2 سال کے لیے 1 X خصوصیات ہیں۔ تاکہ ہم بغیر کسی پریشانی کے آگے بڑھ سکیں۔

ٹینسر فلو کے ساتھ درجہ بندی کے لیے نیورل نیٹ ورک کی ماڈلنگ میں اقدامات

TensorFlow میں ماڈل بنانے کے لیے طے شدہ مراحل ہیں:

• ایک ماڈل بنانا - فنکشنل یا سیکوینشل API کا استعمال کرتے ہوئے نیورل نیٹ ورک کی تہوں کو اکٹھا کریں۔
• ایک ماڈل مرتب کرنا - اس بات کی وضاحت کرنا کہ ماڈل کی کارکردگی کی پیمائش کیسے کی جانی چاہیے، اور اسے کیسے بہتر ہونا چاہیے (نقصان کا فنکشن اور آپٹیمائزر)
• موڈ فٹ کرناl - ماڈل کو ڈیٹا میں پیٹرن تلاش کرنے دینا

ہم ترتیب والے API کا استعمال کریں گے۔ تو، آئیے شروع کرتے ہیں۔

tf.random.set_seed(42)

model_1 = tf.keras.Sequential([tf.keras.layers.Dense(1)])

 optimizer = tf.keras.optimizers.SGD(), #SGD کا مطلب ہے Stochastic Gradient Descent metrics = ['accuracy']) model_1.fit(X, y, epochs = 5)

>> عہد 1/5 32/32 [==============================] - 1s 1ms/step - نقصان: 2.8544 - درستگی: 0.4600 Epoch 2/5 32/32 [==============================] - 0s 2ms/step - loss : 0.7131 - درستگی: 0.5430 Epoch 3/5 32/32 [===============================] - 0s 2ms/step - نقصان: 0.6973 - درستگی: 0.5090 عہد 4/5 32/32 [================================] - 0s 2ms /step - نقصان: 0.6950 - درستگی: 0.5010 Epoch 5/5 32/32 [================================] - 0s 1ms/step - نقصان: 0.6942 - درستگی: 0.4830

ماڈل کی درستگی تقریباً 50% ہے جس کا بنیادی مطلب یہ ہے کہ ماڈل صرف اندازہ لگا رہا ہے، آئیے اسے مزید تربیت دینے کی کوشش کرتے ہیں۔

model_1.fit(X, y, epochs = 200, verbose = 0) #ہم نے تربیتی طریقہ کار کو ہٹانے کے لیے verbose = 0 سیٹ کیا ہے ) model_1.evaluate(X, y)

>> 32/32 [==============================] - 0s 1ms/step - نقصان: 0.6935 - درستگی: 0.5000 [0.6934829950332642، 0.5]

یہاں تک کہ 200 عہدوں کے بعد، یہ اب بھی اس طرح کارکردگی کا مظاہرہ کرتا ہے جیسے یہ اندازہ لگا رہا ہو اگلا مرحلہ مزید تہوں کا اضافہ کر رہا ہے اور طویل عرصے تک تربیت کر رہا ہے۔

tf.random.set_seed(42)

model_2 = tf.keras.Sequential([ tf.keras.layers.Dense(1), tf.keras.layers.Dense(1) ]) model_2.compile(loss = tf.keras.losses.BinaryCrossentropy(), optimizer = tf.keras.optimizers.SGD(), metrics = ['accuracy']) model_2.fit(X, y, epochs = 100, verbose = 0)

 model_2.evaluate(X,y)

>> 32/32 [==============================] - 0s 1ms/step - نقصان: 0.6933 - درستگی: 0.5000 [0.6933314800262451، 0.5]

پھر بھی، تھوڑی سی بھی تبدیلی نہیں آئی، لگتا ہے کچھ گڑبڑ ہے۔

Tensorflow کے ساتھ درجہ بندی کے ماڈل کے لیے اعصابی نیٹ ورک کو بہتر بنانا

مختلف مراحل میں ماڈل کو بہتر بنانے کے مختلف طریقے ہیں:

• ماڈل بنانا - مزید پرتیں شامل کریں، پوشیدہ اکائیوں (نیورونز) کی تعداد میں اضافہ کریں، ہر پرت کے ایکٹیویشن کے افعال کو تبدیل کریں۔
• ایک ماڈل مرتب کرنا - مختلف اصلاحی افعال آزمائیں، مثال کے طور پر SGD() کی بجائے Adam() استعمال کریں۔
• ماڈل فٹ کرنا - ہم عہدوں کی تعداد بڑھا سکتے ہیں۔

آئیے کوشش کرتے ہیں۔ مزید نیوران شامل کریں اور کوشش کریں آدم اصلاح کار

tf.random.set_seed(42)

model_3 = tf.keras.Sequential([ tf.keras.layers.Dense(100), # 100 گھنے نیوران tf.keras.layers.Dense(10) شامل کریں، # 10 نیوران tf.keras.layers.Dense کے ساتھ ایک اور پرت شامل کریں (1) ]) model_3.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(), metrics=['accuracy']) model_3.fit(X, y, epochs =100، فعل=0)

model_3.evaluate(X,y) >> 32/32 [===============================] - 0s 1ms/step - نقصان: 0.6980 - درستگی: 0.5080 [0.6980254650115967، 0.5080000162124634]

اب بھی بہتر نہیں ہو رہا ہے! آئیے اعداد و شمار کو دیکھیں کہ کیا غلط ہو رہا ہے۔

نیورل نیٹ ورک ماڈل کا تصور کریں۔

اپنے ماڈل کی پیشین گوئیوں کو دیکھنے کے لیے ہم ایک فنکشن بنانے جا رہے ہیں plot_decision_boundary() جو:

• ایک تربیت یافتہ ماڈل، خصوصیات اور لیبل لیتا ہے۔
• مختلف X اقدار کا میش گرڈ بنائیں۔
• پورے میش گرڈ میں پیشین گوئیاں کرتا ہے۔
• پیشین گوئیوں کو لائن کے ساتھ پلاٹ کرتا ہے۔

نوٹ:  اس فنکشن کو دو وسائل سے ڈھال لیا گیا ہے:

CS231n ML بنیادی باتوں کے ساتھ بنایا گیا۔ 

def plot_decision_boundary(model, X, y): # پلاٹ کی محور حدود کی وضاحت کریں اور ایک meshgrid x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + بنائیں 0.1 y_min، y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1 xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np .linspace(y_min, y_max, 100)) # X اقدار بنائیں (ہم ان سب کے بارے میں پیشین گوئی کرنے جا رہے ہیں) x_in = np.c_[xx.ravel(), yy.ravel()] # تربیت یافتہ کا استعمال کرتے ہوئے پیشین گوئیاں کریں ماڈل y_pred = model.predict(x_in) # ملٹی کلاس کے لیے چیک کریں۔

 if len(y_pred[0]) > 1: پرنٹ("ملٹی کلاس کی درجہ بندی کرنا...") # ہمیں اپنی پیشین گوئیوں کو پلاٹ کرنے کے لیے ان کی تشکیل نو کرنا ہوگی y_pred = np.argmax(y_pred, axis=1) reshape( xx.shape) else: print("doing binary classifcation...") y_pred = np.round(y_pred).reshape(xx.shape) # پلاٹ کے فیصلے کی حد plt.contourf(xx, yy, y_pred, cmap=plt. cm.RdYlBu, alpha=0.7) plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu) plt.xlim(xx.min( , xx.max()) plt.ylim(yy.min(), yy.max()) plot_decision_boundary(model_3, X, y)

یہ رہا! ایک بار پھر تصور ہمیں دکھاتا ہے کہ کیا غلط ہے اور کیا کرنا ہے؟ ہمارا ماڈل ڈیٹا کے ذریعے سیدھی لکیر کھینچنے کی کوشش کر رہا ہے، لیکن ہمارا ڈیٹا سیدھی لائن سے الگ نہیں کیا جا سکتا۔ ہمارے درجہ بندی کے مسئلے میں کچھ کمی ہے؟ یہ کیا ہے؟

یہ غیر خطی ہے! ہمیں کچھ غیر لکیری لائنوں کی ضرورت ہے۔ آپ اب الجھن میں پڑ سکتے ہیں، اگر آپ سوچ رہے ہیں کہ آپ نے اس قسم کا فنکشن پہلے نہیں دیکھا، تو آپ غلط ہیں، کیونکہ آپ کے پاس ہے۔ آئیے انہیں بصری طور پر دیکھتے ہیں۔ تصور ہمیشہ بہتر کام کرتا ہے!

نیورل نیٹ ورک میں کچھ ایکٹیویشن فنکشنز ہیں جنہیں ہم استعمال کر سکتے ہیں، جیسے ریلو, سگمائڈ. آئیے تھوڑا سا تخلیق کرتے ہیں۔ کھلونا ٹینسر اور اس پر ان افعال کو چیک کریں۔

نیورل نیٹ ورکس کے لیے ایکٹیویشن فنکشنز

A = tf.cast(tf.range(-12,12), tf.float32) print(A) >> tf.Tensor( [-12. -11. -10. -9. -8. -7. - 6. -5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.]، شکل=(24،) dtype=float32)

آئیے دیکھتے ہیں کہ ہمارا کھلونا ٹینسر کیسا لگتا ہے؟

plt.plot(A)

ایسا لگتا ہے، ایک سیدھی لکیر! 

اب آئیے ایکٹیویشن فنکشنز کو دوبارہ بنائیں یہ دیکھنے کے لیے کہ وہ ہمارے ٹینسر کا کیا کرتے ہیں؟

سگمائیڈ:

def sigmoid(x): واپسی 1 / (1 + tf.exp(-x)) sigmoid(A) plt.plot(sigmoid(A))

ایک غیر سیدھی لائن!

ReLu:

def relu(x): واپس tf.maximum(0,x) plt.plot(relu(A))

ایک اور غیر سیدھی لائن!

اب آپ نے غیر لکیری ایکٹیویشن فنکشنز دیکھے ہیں، اور یہ وہی ہیں جو ہمارے لیے کام کریں گے، ماڈل لکیری ایکٹیویشن فنکشن کے ساتھ نان لکیری ڈیٹاسیٹ پر کچھ نہیں سیکھ سکتا! اگر آپ نے یہ سیکھ لیا ہے، تو اب وقت آگیا ہے کہ ہم اپنے ڈیٹا کو تربیت اور ٹیسٹ سیٹس میں تقسیم کریں اور مضبوط ماڈلز بنائیں۔

X_train, y_train = X[:800], y[:800] X_test, y_test = X[800:], y[800:] X_train.shape, X_test.shape >>((800, 2), (200, 2) ))

tf.random.set_seed(42)

model_4 = tf.keras.Sequential([ tf.keras.layers.Dense(4, activation = 'relu'), #ہم اسے درست کر سکتے ہیں "tf.keras.activations.relu" بھی tf.keras.layers.Dense(4 , activation = 'relu'), tf.keras.layers.Dense(1, activation = 'sigmoid') ]) model_4.compile( loss= tf.keras.losses.binary_crossentropy, optimizer = tf.keras.optimizers.Adam( lr = 0.01)، میٹرکس = ['accuracy']) model_4.fit(X_train, y_train, epochs = 25, verbose = 0)

ماڈل کا اندازہ لگائیں۔

نقصان، درستگی = model_4.evaluate(X_test, y_test) پرنٹ (f' ٹیسٹ سیٹ پر ماڈل کا نقصان: {loss}') پرنٹ (f' ٹیسٹ سیٹ پر ماڈل کی درستگی: {100*ccuracy}')

>> 7/7 [==============================] - 0s 2ms/step - نقصان: 0.1247 - درستگی: 1.0000 ٹیسٹ سیٹ پر ماڈل کا نقصان: 0.1246885135769844 ٹیسٹ سیٹ پر ماڈل کی درستگی: 100.0

plt.figure(figsize=(12, 6)) plt.subplot(1, 2, 1) plt.title("ٹرین") plot_decision_boundary(model_4, X=X_train, y=y_train) plt.subplot(1, 2, 2) plt.title("ٹیسٹ") plot_decision_boundary(model_4, X=X_test, y=y_test) plt.show()

آئیے ایک مختصر جائزہ لیتے ہیں کہ ہم اس مضمون میں کس کے بارے میں بات کر رہے ہیں۔ ہم نے مل کر دیکھا کہ ٹینسر فلو کے ساتھ نیورل نیٹ ورک میں درجہ بندی کے کام تک کیسے پہنچنا ہے۔ ہم نے ذہن میں آنے والے پہلے طریقے سے 3 ماڈل بنائے، اور ویژولائزیشن کی مدد سے ہمیں احساس ہوا کہ ہم کہاں غلط تھے، ہم نے لکیریٹی، نان لائنیرٹی کو تلاش کیا، اور آخر کار، ہم ایک عمومی ماڈل بنانے میں کامیاب ہو گئے۔ میں ان تمام کوڈز اور ان اقدامات کے ساتھ جو دکھانے کی کوشش کر رہا تھا وہ یہ تھا کہ کوئی بھی چیز 100 فیصد درست یا طے شدہ نہیں ہے، ہر روز ہر چیز بدلتی رہتی ہے۔ یہ اندازہ لگانے کے لیے کہ آپ کو کس قسم کے ڈیٹا میں کس پریشانی کا سامنا کرنا پڑ سکتا ہے اور یہ دیکھنے کے لیے کہ کون سے مجموعے بہتر نتیجہ کی طرف لے جاتے ہیں، آپ کو بس بہت زیادہ کوڈ لکھنے اور تجربہ حاصل کرنے کی ضرورت ہے۔

مجھے امید ہے کہ مضمون آپ کے لئے تھوڑا مددگار تھا اور کچھ شراکت کی.

اس مضمون میں دکھایا گیا میڈیا Analytics ودھیا کی ملکیت نہیں ہے اور مصنف کی صوابدید پر استعمال کیا جاتا ہے۔

متعلقہ

ماخذ: https://www.analyticsvidhya.com/blog/2021/11/neural-network-for-classification-with-tensorflow/