Tutorial sa TensorFlow para sa mga Baguhan
Ang TensorFlow ay isa sa mga pinakasikat na framework para sa deep learning at machine learning. Binuo ng Google Brain team, ang TensorFlow ay malawakang ginagamit sa maraming proyekto sa pananaliksik at mga aplikasyong pang-industriya. Ang artikulong ito ay nagbibigay ng sunud-sunod na tutorial upang matulungan ka, bilang isang baguhan, na makapagsimula sa TensorFlow.
1. Pag-unawa sa mga Pangunahing Kaalaman sa TensorFlow
Bago natin simulan ang pag-install at paggamit ng TensorFlow, mahalagang maunawaan muna kung ano ang TensorFlow at ang mga pangunahing konsepto sa likod nito. Ang TensorFlow ay isang open-source framework para sa numerical computation at machine learning. Gumagamit ito ng mga data flow graph upang magsagawa ng mga numerical operation, kung saan ang mga node sa graph ay kumakatawan sa mga mathematical operation, at ang mga edge ay kumakatawan sa mga multidimensional data array (tensor) na konektado sa pagitan ng mga ito.
2. Pag-install ng TensorFlow
Ang unang hakbang sa paggamit ng TensorFlow ay ang pag-install nito. Narito kung paano i-install ang TensorFlow gamit ang pip, ang Python package manager.
1. Pag-install ng Python:
Siguraduhing naka-install ang Python sa iyong system. Ang TensorFlow ay tugma sa Python 3.6 hanggang 3.9 sa panahon ng pagsulat nito. Maaari mong i-download ang Python mula sa opisyal na website ng Python.
2. Birtwal na Kapaligiran:
Lubos na inirerekomenda na lumikha ng isang virtual na kapaligiran upang ihiwalay ang iyong proyektong TensorFlow:
"sh"
python -m venv myenv
source myenv/bin/activate Para sa mga gumagamit ng Mac/Linux
myenv\Scripts\activate Para sa mga gumagamit ng Windows
""
3. Pag-install ng TensorFlow:
Ngayon, i-install ang TensorFlow gamit ang pip:
"sh"
pip install tensorflow
""
3. Kumusta Mundo gamit ang TensorFlow
Ngayong naka-install na ang TensorFlow, gumawa tayo ng simpleng Python script para beripikahin ang instalasyon. Gumawa ng bagong Python file at pangalanan itong `hello_tensorflow.py`.
“`python
mag-import ng tensorflow bilang tf
Gumawa ng isang pare-pareho
kumusta = tf.constant('Kumusta, TensorFlow!')
Simulan ang sesyon
gamit ang tf.Session() bilang sess:
resulta = sess.run(hello)
print(resulta)
""
Iangkop ang code ayon sa TensorFlow bersyon 2.x:
“`python
mag-import ng tensorflow bilang tf
Gumawa ng isang pare-pareho
kumusta = tf.constant('Kumusta, TensorFlow!')
Patakbuhin gamit ang eager execution (naka-on bilang default)
print(hello.numpy())
""
I-save ang file, pagkatapos ay patakbuhin:
"sh"
python hello_tensorflow.py
""
4. Pag-unawa sa mga Tensor at mga Pangunahing Operasyon
Ang mga tensor ang pangunahing istruktura ng datos sa TensorFlow, na isang multidimensional array. Narito ang ilang halimbawa upang matulungan kang maunawaan ang mga tensor:
“`python
mag-import ng tensorflow bilang tf
Paglikha ng mga tensor
eskalar = tf. constant(7) eskalar
vector = tf. constant([1, 2, 3]) vector
matris = tf. konstante([[1, 2], [3, 4]]) matris
tensor3d = tf.constant([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]) 3D na tensor
print(f'Iskalar: {iskalar}')
print(f'Vector: {vector}')
print(f'Matrix: {matrix}')
print(f'Tensor 3D: {tensor3d}')
""
Para maisagawa ang mga pangunahing operasyon sa mga tensor:
“`python
a = tf.constant([[1, 2], [3, 4]])
b = tf.constant([[5, 6], [7, 8]])
Operasyon ng pagdaragdag
idagdag = tf.add(a, b)
Mga operasyon sa pagpaparami ng matrix
mul = tf.matmul(a, b)
print(f'Pagdaragdag: {idagdag}')
print(f'Pagpaparami ng Matrix: {mul}')
""
5. Paglikha ng Isang Simpleng Modelo ng Neural Network
Ang susunod na hakbang ay ang paglikha ng isang simpleng modelo ng neural network. Bubuo tayo ng isang modelo ng klasipikasyon ng imahe gamit ang MNIST dataset, isang database ng mga sulat-kamay na digit na imahe. Simulan na natin:
“`python
mag-import ng tensorflow bilang tf
mula sa tensorflow.keras, i-import ang mga dataset, layer, at modelo
Pag-download ng dataset ng MNIST
(mga_larawan_ng_tren, mga_label_ng_tren), (mga_larawan_ng_pagsubok, mga_label_ng_pagsubok) = mga_dataset.mnist.load_data()
Normalisasyon ng imahe
mga_larawan_ng_tren, mga_larawan_ng_pagsubok = mga_larawan_ng_tren / 255.0, mga_larawan_ng_pagsubok / 255.0
Paggawa ng modelo
modelo = mga modelo.Sequential([
mga layer.Patagin(input_hugis=(28, 28)),
layers.Dense(128, activation='relu'),
mga layer. Siksik(10)
])
Kompilasyon ng modelo
model.compile(optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=Totoo),
metrics=['katumpakan'])
Pagsasanay sa modelo
modelo.akma(mga_larawan_ng_tren, mga_label_ng_tren, mga_epoch=5)
Pagsubok sa modelo
test_loss, test_acc = model.evaluate(mga_larawan_ng_pagsubok, mga_label_ng_pagsubok)
print(f'Katumpakan ng Pagsubok: {test_acc}')
""
Paliwanag:
– Mga Dataset: Ini-import at nilo-load namin ang dataset ng MNIST.
– Paunang Pagproseso: I-normalize ang dataset sa pamamagitan ng paghahati ng mga halaga ng pixel sa 255.
– Modelo: Tinutukoy namin ang isang simpleng modelo na may dalawang layer. Ang unang layer ay isang `Flatten` layer upang i-convert ang 2D na imahe sa isang 1D array. Ang pangalawang layer ay isang `Dense` layer na may 128 neurons at `relu` bilang activation function, at ang pangalawa ay isang `Dense` layer na may 10 neurons na kumakatawan sa 10 klase.
– Pag-compile: Kino-compile namin ang modelo gamit ang `adam` optimizer at `SparseCategoricalCrossentropy` bilang loss function.
– Sanayin: Sanayin ang modelo sa loob ng 5 epoch.
– Suriin: Suriin ang modelo laban sa datos ng pagsubok.
6. Mga Modelo ng Pag-save at Paglo-load
Pagkatapos sanayin ang isang modelo, maaari mo itong i-save para magamit sa ibang pagkakataon nang hindi na kailangang sanayin muli. Narito kung paano i-save at i-load ang isang modelo:
“`python
Pag-save ng modelo
modelo.save('aking_modelo.h5')
Naglo-load na modelo
bagong_modelo = tf.keras.models.load_model('aking_modelo.h5′)
Pag-verify ng na-load na modelo
pagkawala, acc = new_model.evaluate(mga_larawan_ng_pagsubok, mga_label_ng_pagsubok)
print(f'Katumpakan ng na-load na modelo: {acc}')
""
Konklusyon
Ang gabay na ito ay nagbibigay ng detalyadong panimula sa pagsisimula sa TensorFlow para sa mga nagsisimula. Tinalakay na natin ang pag-install, mga pangunahing operasyon ng tensor, at pagbuo ng isang simpleng modelo ng neural network gamit ang dataset ng MNIST. Nag-aalok ang TensorFlow ng maraming advanced na kakayahan na maaaring tuklasin, tulad ng advanced na pagproseso ng data, mas kumplikadong mga modelo, at paggamit ng TensorFlow sa mga device tulad ng mga TPU at GPU. Umaasa kami na makakatulong sa iyo ang tutorial na ito na makapagsimula sa mundo ng machine learning gamit ang TensorFlow.
