 TensorFlow.org पर देखें |  Google Colab में चलाएं |  गिटहब पर देखें |  नोटबुक डाउनलोड करें |
यह Colab का उपयोग कर का एक प्रदर्शन है Tensorflow हब गैर अंग्रेजी / स्थानीय भाषाओं में पाठ वर्गीकरण के लिए। यहाँ हम चुनें बांग्ला स्थानीय भाषा के रूप में और एक multiclass वर्गीकरण कार्य है जहाँ हम 5 श्रेणियों में बांग्ला समाचार लेखों का वर्गीकरण को हल करने के शब्द embeddings pretrained का उपयोग करें। बांग्ला के लिए pretrained embeddings से आता है fastText जो 157 भाषाओं के लिए जारी किया गया pretrained शब्द वैक्टर के साथ फेसबुक से एक पुस्तकालय है।
हम पहले एक पाठ embedding मॉड्यूल के लिए शब्द embeddings परिवर्तित करने के लिए TF-हब के pretrained embedding निर्यातक इस्तेमाल करेंगे और उसके बाद के साथ एक वर्गीकारक प्रशिक्षित करने के लिए मॉड्यूल का उपयोग tf.keras , Tensorflow के उच्च स्तर उपयोगकर्ता के अनुकूल एपीआई गहरी सीखने मॉडल बनाने के लिए। यहां तक कि अगर हम यहां फास्टटेक्स्ट एम्बेडिंग का उपयोग कर रहे हैं, तो अन्य कार्यों से पूर्व-प्रशिक्षित किसी भी अन्य एम्बेडिंग को निर्यात करना संभव है और जल्दी से Tensorflow हब के साथ परिणाम प्राप्त करना संभव है।
सेट अप
# https://github.com/pypa/setuptools/issues/1694#issuecomment-466010982pip install gdown --no-use-pep517
sudo apt-get install -y unzip
Reading package lists... Building dependency tree... Reading state information... unzip is already the newest version (6.0-21ubuntu1.1). The following packages were automatically installed and are no longer required: linux-gcp-5.4-headers-5.4.0-1040 linux-gcp-5.4-headers-5.4.0-1043 linux-gcp-5.4-headers-5.4.0-1044 linux-gcp-5.4-headers-5.4.0-1049 linux-headers-5.4.0-1049-gcp linux-image-5.4.0-1049-gcp linux-modules-5.4.0-1049-gcp linux-modules-extra-5.4.0-1049-gcp Use 'sudo apt autoremove' to remove them. 0 upgraded, 0 newly installed, 0 to remove and 143 not upgraded.
import os
import tensorflow as tf
import tensorflow_hub as hub
import gdown
import numpy as np
from sklearn.metrics import classification_report
import matplotlib.pyplot as plt
import seaborn as sns
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/pkg_resources/__init__.py:119: PkgResourcesDeprecationWarning: 0.18ubuntu0.18.04.1 is an invalid version and will not be supported in a future release PkgResourcesDeprecationWarning,
डेटासेट
हम का उपयोग करेगा चारण अर्थव्यवस्था, राज्य, अंतरराष्ट्रीय, खेल संबंधी और मनोरंजन: (बांग्ला अनुच्छेद डेटासेट) जो चारों ओर 376,226 लेख विभिन्न बांग्ला समाचार पोर्टलों से एकत्र और 5 श्रेणियों के साथ लेबल है। हम इस (Google डिस्क से फ़ाइल डाउनलोड bit.ly/BARD_DATASET ) लिंक से करने के लिए बात कर रहा है इस GitHub भंडार।
gdown.download(
url='https://drive.google.com/uc?id=1Ag0jd21oRwJhVFIBohmX_ogeojVtapLy',
output='bard.zip',
quiet=True
)
'bard.zip'
unzip -qo bard.zip
टीएफ-हब मॉड्यूल में पूर्व-प्रशिक्षित शब्द वैक्टर निर्यात करें
TF-हब TF-हब पाठ एम्बेडिंग मॉड्यूल करने के लिए शब्द embeddings परिवर्तित करने के लिए कुछ उपयोगी स्क्रिप्ट प्रदान करता है यहां । बांग्ला या किसी अन्य भाषाओं के लिए मॉड्यूल बनाने के लिए हम बस शब्द को एम्बेड डाउनलोड करने के लिए है .txt या .vec रूप में एक ही निर्देशिका में फाइल को export_v2.py और स्क्रिप्ट चलाने।
निर्यातक embedding वैक्टर पढ़ता है और एक Tensorflow करने के लिए इसे निर्यात SavedModel । सहेजे गए मॉडल में वज़न और ग्राफ़ सहित एक संपूर्ण TensorFlow प्रोग्राम होता है। TF-हब के रूप में एक SavedModel लोड कर सकते हैं मॉड्यूल है, जो हम पाठ वर्गीकरण के लिए मॉडल बनाने के लिए प्रयोग करेंगे। हम प्रयोग कर रहे हैं के बाद से tf.keras मॉडल बनाने के लिए, हम का उपयोग करेगा hub.KerasLayer है, जो एक Keras परत के रूप में उपयोग करने के लिए एक TF-हब मॉड्यूल के लिए एक आवरण प्रदान करता है।
पहले हम TF-हब से fastText से हमारे शब्द embeddings और एम्बेडिंग निर्यातक मिल जाएगा रेपो ।
curl -O https://dl.fbaipublicfiles.com/fasttext/vectors-crawl/cc.bn.300.vec.gzcurl -O https://raw.githubusercontent.com/tensorflow/hub/master/examples/text_embeddings_v2/export_v2.pygunzip -qf cc.bn.300.vec.gz --k
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 840M 100 840M 0 0 11.6M 0 0:01:12 0:01:12 --:--:-- 12.0M
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 7469 100 7469 0 0 19053 0 --:--:-- --:--:-- --:--:-- 19005
फिर, हम अपनी एम्बेडिंग फ़ाइल पर एक्सपोर्टर स्क्रिप्ट चलाएंगे। चूंकि फास्टटेक्स्ट एम्बेडिंग में एक हेडर लाइन होती है और बहुत बड़ी होती है (मॉड्यूल में कनवर्ट करने के बाद बांग्ला के लिए लगभग 3.3 जीबी) हम पहली पंक्ति को अनदेखा करते हैं और टेक्स्ट एम्बेडिंग मॉड्यूल में केवल पहले 100, 000 टोकन निर्यात करते हैं।
python export_v2.py --embedding_file=cc.bn.300.vec --export_path=text_module --num_lines_to_ignore=1 --num_lines_to_use=100000
INFO:tensorflow:Assets written to: text_module/assets I1105 11:55:29.817717 140238757988160 builder_impl.py:784] Assets written to: text_module/assets
module_path = "text_module"
embedding_layer = hub.KerasLayer(module_path, trainable=False)
टेक्स्ट एम्बेडिंग मॉड्यूल इनपुट के रूप में स्ट्रिंग्स के 1D टेंसर में वाक्यों का एक बैच लेता है और वाक्यों के अनुरूप आकार के एम्बेडिंग वैक्टर (बैच_साइज़, एम्बेडिंग_डिम) को आउटपुट करता है। यह रिक्त स्थान पर विभाजित करके इनपुट को प्रीप्रोसेस करता है। वर्ड embeddings साथ वाक्य embeddings के लिए जोड़ा जाता sqrtn combiner (देखें यहाँ )। प्रदर्शन के लिए हम इनपुट के रूप में बांग्ला शब्दों की एक सूची पास करते हैं और संबंधित एम्बेडिंग वैक्टर प्राप्त करते हैं।
embedding_layer(['বাস', 'বসবাস', 'ট্রেন', 'যাত্রী', 'ট্রাক'])
<tf.Tensor: shape=(5, 300), dtype=float64, numpy=
array([[ 0.0462, -0.0355, 0.0129, ..., 0.0025, -0.0966, 0.0216],
[-0.0631, -0.0051, 0.085 , ..., 0.0249, -0.0149, 0.0203],
[ 0.1371, -0.069 , -0.1176, ..., 0.029 , 0.0508, -0.026 ],
[ 0.0532, -0.0465, -0.0504, ..., 0.02 , -0.0023, 0.0011],
[ 0.0908, -0.0404, -0.0536, ..., -0.0275, 0.0528, 0.0253]])>
Tensorflow डेटासेट में कनवर्ट करें
चूंकि डाटासेट वास्तव में के बजाय स्मृति में पूरे डाटासेट लोड करने की बड़ी है हम प्रयोग कर बैचों में रन-टाइम में नमूने उपज के लिए एक जनरेटर का उपयोग करेगा Tensorflow डेटासेट कार्य करता है। डेटासेट भी बहुत असंतुलित है, इसलिए, जनरेटर का उपयोग करने से पहले, हम डेटासेट को फेरबदल करेंगे।
dir_names = ['economy', 'sports', 'entertainment', 'state', 'international']
file_paths = []
labels = []
for i, dir in enumerate(dir_names):
file_names = ["/".join([dir, name]) for name in os.listdir(dir)]
file_paths += file_names
labels += [i] * len(os.listdir(dir))
np.random.seed(42)
permutation = np.random.permutation(len(file_paths))
file_paths = np.array(file_paths)[permutation]
labels = np.array(labels)[permutation]
हम फेरबदल के बाद प्रशिक्षण और सत्यापन उदाहरणों में लेबल के वितरण की जांच कर सकते हैं।
train_frac = 0.8
train_size = int(len(file_paths) * train_frac)
# plot training vs validation distribution
plt.subplot(1, 2, 1)
plt.hist(labels[0:train_size])
plt.title("Train labels")
plt.subplot(1, 2, 2)
plt.hist(labels[train_size:])
plt.title("Validation labels")
plt.tight_layout()
एक बनाने के लिए डेटासेट एक जनरेटर का उपयोग, हम पहले एक जनरेटर समारोह जहाँ से प्रत्येक लेख पढ़ता लिखने file_paths लेबल सरणी से और लेबल, और पैदावार प्रत्येक चरण में एक प्रशिक्षण उदाहरण। हम करने के लिए इस जनरेटर समारोह पारित tf.data.Dataset.from_generator विधि और आउटपुट प्रकार निर्दिष्ट। प्रत्येक प्रशिक्षण उदाहरण के एक लेख से युक्त एक टपल है tf.string डेटा प्रकार और एक गर्म एन्कोडेड लेबल। हम का उपयोग कर 80-20 की एक ट्रेन-मान्यता विभाजन के साथ डाटासेट विभाजित tf.data.Dataset.skip और tf.data.Dataset.take तरीकों।
def load_file(path, label):
return tf.io.read_file(path), label
def make_datasets(train_size):
batch_size = 256
train_files = file_paths[:train_size]
train_labels = labels[:train_size]
train_ds = tf.data.Dataset.from_tensor_slices((train_files, train_labels))
train_ds = train_ds.map(load_file).shuffle(5000)
train_ds = train_ds.batch(batch_size).prefetch(tf.data.AUTOTUNE)
test_files = file_paths[train_size:]
test_labels = labels[train_size:]
test_ds = tf.data.Dataset.from_tensor_slices((test_files, test_labels))
test_ds = test_ds.map(load_file)
test_ds = test_ds.batch(batch_size).prefetch(tf.data.AUTOTUNE)
return train_ds, test_ds
train_data, validation_data = make_datasets(train_size)
मॉडल प्रशिक्षण और मूल्यांकन
जब से हम पहले से ही हमारे मॉड्यूल Keras में किसी भी अन्य परत के रूप में उपयोग करने के लिए चारों ओर एक आवरण को शामिल किया है, हम एक छोटे से बना सकते हैं अनुक्रमिक मॉडल है जो परतों की एक रेखीय ढेर है। हम साथ हमारे पाठ embedding मॉड्यूल जोड़ सकते हैं model.add किसी भी अन्य परत की तरह। हम नुकसान और अनुकूलक को निर्दिष्ट करके मॉडल को संकलित करते हैं और इसे 10 युगों के लिए प्रशिक्षित करते हैं। tf.keras एपीआई, इनपुट के रूप में Tensorflow डेटासेट संभाल कर सकते हैं तो हम मॉडल प्रशिक्षण के लिए फिट करने के लिए एक विधि डेटासेट उदाहरण पारित कर सकते हैं। हम जनरेटर समारोह का उपयोग कर रहे हैं, tf.data , नमूने पैदा करने के लिए उन्हें batching और उन्हें मॉडल को खिलाने को संभाल लेंगे।
नमूना
def create_model():
model = tf.keras.Sequential([
tf.keras.layers.Input(shape=[], dtype=tf.string),
embedding_layer,
tf.keras.layers.Dense(64, activation="relu"),
tf.keras.layers.Dense(16, activation="relu"),
tf.keras.layers.Dense(5),
])
model.compile(loss=tf.losses.SparseCategoricalCrossentropy(from_logits=True),
optimizer="adam", metrics=['accuracy'])
return model
model = create_model()
# Create earlystopping callback
early_stopping_callback = tf.keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=3)
प्रशिक्षण
history = model.fit(train_data,
validation_data=validation_data,
epochs=5,
callbacks=[early_stopping_callback])
Epoch 1/5 1176/1176 [==============================] - 34s 28ms/step - loss: 0.2181 - accuracy: 0.9279 - val_loss: 0.1580 - val_accuracy: 0.9449 Epoch 2/5 1176/1176 [==============================] - 32s 27ms/step - loss: 0.1411 - accuracy: 0.9505 - val_loss: 0.1411 - val_accuracy: 0.9503 Epoch 3/5 1176/1176 [==============================] - 32s 27ms/step - loss: 0.1307 - accuracy: 0.9534 - val_loss: 0.1359 - val_accuracy: 0.9524 Epoch 4/5 1176/1176 [==============================] - 32s 27ms/step - loss: 0.1248 - accuracy: 0.9555 - val_loss: 0.1318 - val_accuracy: 0.9527 Epoch 5/5 1176/1176 [==============================] - 32s 27ms/step - loss: 0.1196 - accuracy: 0.9567 - val_loss: 0.1247 - val_accuracy: 0.9555
मूल्यांकन
हम का उपयोग कर प्रशिक्षण और मान्यता डेटा के लिए सटीकता और नुकसान घटता कल्पना कर सकते हैं tf.keras.callbacks.History वस्तु द्वारा दिया tf.keras.Model.fit विधि है, जो प्रत्येक युग के लिए नुकसान और सटीकता मान है।
# Plot training & validation accuracy values
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('Model accuracy')
plt.ylabel('Accuracy')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
# Plot training & validation loss values
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('Model loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
भविष्यवाणी
हम सत्यापन डेटा के लिए भविष्यवाणियां प्राप्त कर सकते हैं और 5 वर्गों में से प्रत्येक के लिए मॉडल के प्रदर्शन को देखने के लिए भ्रम मैट्रिक्स की जांच कर सकते हैं। क्योंकि tf.keras.Model.predict विधि प्रत्येक वर्ग के लिए संभावनाओं के लिए एक nd सरणी देता है, वे उपयोग कर वर्ग लेबल में बदला जा सकता np.argmax ।
y_pred = model.predict(validation_data)
y_pred = np.argmax(y_pred, axis=1)
samples = file_paths[0:3]
for i, sample in enumerate(samples):
f = open(sample)
text = f.read()
print(text[0:100])
print("True Class: ", sample.split("/")[0])
print("Predicted Class: ", dir_names[y_pred[i]])
f.close()
রবিন উইলিয়ামস তাঁর হ্যাপি ফিট ছবিতে মজা করে বলেছিলেন, ‘আমি শুনতে পাচ্ছি, মানুষ কিছু একটা চাইছে...সে True Class: entertainment Predicted Class: state নির্মাণ শেষে ফিতা কেটে মন্ত্রী ভবন উদ্বোধন করেছেন বহু আগেই। তবে এখনো চালু করা যায়নি খাগড়াছড়ি জেল True Class: state Predicted Class: state কমলাপুর বীরশ্রেষ্ঠ মোস্তফা কামাল স্টেডিয়ামে কাল ফকিরেরপুল ইয়ংমেন্স ক্লাব ৩-০ গোলে হারিয়েছে স্বাধ True Class: sports Predicted Class: state
प्रदर्शन की तुलना करें
अब हम से मान्यता डेटा के लिए सही लेबल ले जा सकते हैं labels और एक पाने के लिए हमारे भविष्यवाणियों के साथ उनकी तुलना classification_report ।
y_true = np.array(labels[train_size:])
print(classification_report(y_true, y_pred, target_names=dir_names))
precision recall f1-score support
economy 0.83 0.76 0.79 3897
sports 0.99 0.98 0.98 10204
entertainment 0.90 0.94 0.92 6256
state 0.97 0.97 0.97 48512
international 0.92 0.93 0.93 6377
accuracy 0.96 75246
macro avg 0.92 0.92 0.92 75246
weighted avg 0.96 0.96 0.96 75246
हम यह भी मूल में प्राप्त प्रकाशित परिणामों के साथ हमारे मॉडल के प्रदर्शन की तुलना कर सकते हैं कागज है, जो एक 0.96 परिशुद्धता व्याप्ति मूल लेखकों कई पूर्व प्रसंस्करण चरणों में इस तरह के, विराम चिह्न और अंक गिर शीर्ष 25 सबसे frequest रोकने वाले शब्द को हटाने के रूप में, डाटासेट पर प्रदर्शन वर्णित किया था। हम में देख सकते हैं classification_report , हम भी किसी भी पूर्व प्रसंस्करण के बिना केवल 5 अवधियों के लिए प्रशिक्षण के बाद एक 0.96 परिशुद्धता और सटीकता प्राप्त करने के लिए प्रबंधन!
इस उदाहरण में, जब हम अपने एम्बेडिंग मॉड्यूल से Keras परत बनाया, हम पैरामीटर सेट trainable=False है, जो embedding वजन प्रशिक्षण के दौरान अपडेट नहीं किया जाएगा मतलब है। करने के लिए यह सेट करने का प्रयास True केवल 2 अवधियों के बाद इस डेटासेट का उपयोग करके करीब 97% सटीकता तक पहुँचने के लिए।