TensorFlow چیست؟ آموزش کامل Keras و ساخت شبکه عصبی با پایتون

TensorFlow یا تنسورفلو یکی از شناخته‌شده‌ترین فریم‌ورک‌های یادگیری ماشین و یادگیری عمیق است. با TensorFlow می‌توان مدل‌های هوش مصنوعی را ساخت، آموزش داد، ارزیابی کرد و در محیط‌های مختلف به اجرا رساند.

اگرچه امروزه بسیاری از توسعه‌دهندگان برای افزودن قابلیت هوش مصنوعی به نرم‌افزار خود از مدل‌های آماده و API استفاده می‌کنند، یادگیری TensorFlow همچنان برای درک شبکه‌های عصبی، ساخت مدل اختصاصی، پردازش داده و توسعه پروژه‌های Machine Learning اهمیت زیادی دارد.

در این مقاله ابتدا مفاهیم پایه TensorFlow و Keras را بررسی می‌کنیم. سپس یک پروژه واقعی تحلیل احساسات متن می‌سازیم که دیدگاه‌های انگلیسی را در دو گروه مثبت و منفی طبقه‌بندی می‌کند.

در پایان این آموزش می‌توانید:

• TensorFlow را نصب و آزمایش کنید.
• با Tensor و عملیات آن کار کنید.
• Gradient را با GradientTape محاسبه کنید.
• داده‌ها را با tf.data مدیریت کنید.
• تفاوت TensorFlow و Keras را توضیح دهید.
• مدل Sequential بسازید.
• از Functional API استفاده کنید.
• مدل پردازش متن ایجاد کنید.
• مدل را با compile و fit آموزش دهید.
• از Callbackهای کاربردی استفاده کنید.
• عملکرد مدل را ارزیابی کنید.
• مدل را ذخیره و دوباره بارگذاری کنید.
• برای متن جدید پیش‌بینی انجام دهید.
• تفاوت ساخت مدل اختصاصی و استفاده از API درواره را تشخیص دهید.

TensorFlow چیست؟

TensorFlow یک پلتفرم متن‌باز یادگیری ماشین است که ابزارهای موردنیاز برای کار با داده، ساخت شبکه عصبی، آموزش مدل و اجرای Inference را فراهم می‌کند.

با TensorFlow می‌توان مدل‌هایی برای کاربردهای زیر ساخت:

• طبقه‌بندی تصویر
• تشخیص اشیا
• تحلیل احساسات
• طبقه‌بندی متن
• پردازش زبان طبیعی
• پیش‌بینی سری زمانی
• سیستم پیشنهاددهنده
• پردازش صوت
• مدل‌های Transformer
• تشخیص ناهنجاری
• رگرسیون
• خوشه‌بندی و پردازش داده
• اجرای مدل روی موبایل، مرورگر، سرور یا فضای ابری

بر اساس معرفی رسمی TensorFlow، این پلتفرم برای ساخت مدل‌های یادگیری ماشین در محیط‌های دسکتاپ، موبایل، وب و Cloud طراحی شده است.

TensorFlow چگونه تلفظ می‌شود؟

TensorFlow از دو بخش تشکیل شده است:

Tensor + Flow

در فارسی معمولاً به شکل‌های زیر نوشته می‌شود:

• تنسورفلو
• تنسور فلو
• TensorFlow

Tensor ساختار چندبعدی داده و Flow به جریان عملیات محاسباتی اشاره دارد.

Keras چیست؟

Keras یک API سطح‌بالا برای ساخت و آموزش مدل‌های یادگیری عمیق است. هنگام استفاده از TensorFlow معمولاً مدل خود را با APIهای Keras می‌سازیم.

نمونه:

from tensorflow import keras
from tensorflow.keras import layers

model = keras.Sequential(
    [
        layers.Input(shape=(100,)),
        layers.Dense(
            64,
            activation="relu",
        ),
        layers.Dense(
            1,
            activation="sigmoid",
        ),
    ]
)

Keras عملیات زیر را ساده می‌کند:

• تعریف لایه‌ها
• ساخت مدل
• تنظیم Loss
• انتخاب Optimizer
• آموزش با fit
• ارزیابی با evaluate
• پیش‌بینی با predict
• ذخیره و بارگذاری مدل
• استفاده از Callback
• نمایش معیارهای آموزش

طبق راهنمای رسمی Keras در TensorFlow، Keras رابط سطح‌بالای TensorFlow برای توسعه مدل‌های Machine Learning و Deep Learning است.

تفاوت Keras 3 و tf.keras

در نسخه‌های جدید، Keras 3 یک فریم‌ورک چندبک‌اندی است که می‌تواند با Backendهای مختلف کار کند؛ از جمله:

• TensorFlow
• PyTorch
• JAX
• OpenVINO برای برخی سناریوهای Inference

اما tf.keras رابط Keras ارائه‌شده در اکوسیستم TensorFlow است.

در این مقاله از این Import استفاده می‌کنیم:

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

این انتخاب باعث می‌شود تمام مثال‌ها با TensorFlow Backend اجرا شوند.

اگر پروژه شما به قابلیت چندبک‌اندی Keras نیاز ندارد، استفاده از tf.keras برای آموزش TensorFlow ساده و روشن است.

تفاوت TensorFlow و Keras

به زبان ساده، TensorFlow زیرساخت اصلی و Keras رابط ساده‌تر ساخت مدل است.

TensorFlow چه تفاوتی با PyTorch دارد؟

هیچ‌کدام در همه پروژه‌ها برتر نیستند. انتخاب به تجربه تیم، مدل، ابزارهای موجود و محیط استقرار بستگی دارد.

Tensor چیست؟

Tensor ساختار اصلی داده در TensorFlow است. Tensor را می‌توان آرایه‌ای چندبعدی دانست.

نمونه Scalar:

import tensorflow as tf

scalar = tf.constant(7)

print(scalar)
print(scalar.shape)

بردار:

vector = tf.constant(
    [1.0, 2.0, 3.0]
)

print(vector)
print(vector.shape)

ماتریس:

matrix = tf.constant(
    [
        [1.0, 2.0],
        [3.0, 4.0],
    ]
)

print(matrix)
print(matrix.shape)

Tensor سه‌بعدی:

tensor_3d = tf.constant(
    [
        [
            [1.0, 2.0],
            [3.0, 4.0],
        ],
        [
            [5.0, 6.0],
            [7.0, 8.0],
        ],
    ]
)

print(tensor_3d.shape)

خروجی:

(2, 2, 2)

Tensor ثابت و Variable

tf.constant برای مقدار ثابت استفاده می‌شود:

constant_value = tf.constant(
    [1.0, 2.0]
)

tf.Variable برای مقداری است که می‌تواند تغییر کند:

weight = tf.Variable(
    [0.5, -0.2]
)

weight.assign(
    [0.6, -0.1]
)

وزن‌های شبکه عصبی در طول آموزش تغییر می‌کنند و به‌صورت Variable مدیریت می‌شوند.

ساخت Tensorهای رایج

Tensor صفر:

zeros = tf.zeros(
    shape=(3, 4)
)

Tensor یک:

ones = tf.ones(
    shape=(2, 3)
)

Tensor تصادفی یکنواخت:

uniform_tensor = tf.random.uniform(
    shape=(3, 3)
)

Tensor تصادفی نرمال:

normal_tensor = tf.random.normal(
    shape=(3, 3)
)

دنباله عددی:

numbers = tf.range(
    start=0,
    limit=10,
    delta=2,
)

ویژگی‌های Tensor

tensor = tf.random.normal(
    shape=(2, 3),
    dtype=tf.float32,
)

print("Shape:", tensor.shape)
print("Rank:", tf.rank(tensor))
print("Data type:", tensor.dtype)
print("Size:", tf.size(tensor))

ویژگی‌های مهم:

• Shape: اندازه هر بُعد
• Rank: تعداد بُعدها
• dtype: نوع داده
• Size: تعداد کل عناصر

عملیات Tensor

import tensorflow as tf

a = tf.constant(
    [1.0, 2.0, 3.0]
)

b = tf.constant(
    [4.0, 5.0, 6.0]
)

print("Addition:", a + b)
print("Subtraction:", a - b)
print("Multiplication:", a * b)
print("Division:", a / b)

ضرب ماتریسی:

matrix_a = tf.random.normal(
    shape=(2, 3)
)

matrix_b = tf.random.normal(
    shape=(3, 4)
)

result = tf.matmul(
    matrix_a,
    matrix_b,
)

print(result.shape)

خروجی:

(2, 4)

تغییر Shape

tensor = tf.range(12)

reshaped = tf.reshape(
    tensor,
    shape=(3, 4),
)

print(reshaped)

افزودن بُعد Batch:

image = tf.random.normal(
    shape=(28, 28)
)

batched_image = tf.expand_dims(
    image,
    axis=0,
)

print(batched_image.shape)

خروجی:

(1, 28, 28)

حذف بُعد:

restored_image = tf.squeeze(
    batched_image,
    axis=0,
)

تبدیل NumPy و TensorFlow

import numpy as np
import tensorflow as tf

numpy_array = np.array(
    [1.0, 2.0, 3.0],
    dtype=np.float32,
)

tensor = tf.convert_to_tensor(
    numpy_array
)

print(tensor)

تبدیل Tensor به NumPy:

array_again = tensor.numpy()

print(array_again)

در حالت Eager Execution می‌توان نتیجه Tensor را مستقیماً به NumPy تبدیل کرد.

Eager Execution چیست؟

در TensorFlow جدید، عملیات معمولاً به‌صورت Eager اجرا می‌شوند؛ یعنی نتیجه هر عملیات بلافاصله قابل مشاهده است:

x = tf.constant(2.0)
y = tf.constant(3.0)

z = x * y

print(z.numpy())

خروجی:

6.0

این رفتار اشکال‌زدایی و درک کد را ساده‌تر می‌کند.

tf.function چیست؟

tf.function می‌تواند یک تابع پایتون را به Graph قابل بهینه‌سازی TensorFlow تبدیل کند:

import tensorflow as tf


@tf.function
def multiply_and_add(
    x,
    y,
):
    return x * y + 1


result = multiply_and_add(
    tf.constant(2.0),
    tf.constant(3.0),
)

print(result)

بهتر است ابتدا کد را در حالت معمولی و Eager آزمایش کنید و سپس برای بخش‌های محاسباتی پایدار از tf.function استفاده کنید.

قرار دادن منطق پیچیده Python، تغییر نوع ورودی یا Side Effect در tf.function ممکن است رفتار غیرمنتظره ایجاد کند.

GradientTape چیست؟

TensorFlow برای محاسبه Gradient از tf.GradientTape استفاده می‌کند.

مثال:

import tensorflow as tf

x = tf.Variable(3.0)

with tf.GradientTape() as tape:
    y = x ** 2 + 2 * x + 1

gradient = tape.gradient(
    y,
    x,
)

print("x:", x.numpy())
print("y:", y.numpy())
print("dy/dx:", gradient.numpy())

تابع:

y = x² + 2x + 1

مشتق:

dy/dx = 2x + 2

برای x = 3 مقدار Gradient برابر ۸ خواهد بود.

Gradient در آموزش شبکه عصبی

در یک حلقه آموزش سفارشی:

with tf.GradientTape() as tape:
    predictions = model(
        inputs,
        training=True,
    )

    loss = loss_fn(
        labels,
        predictions,
    )

gradients = tape.gradient(
    loss,
    model.trainable_variables,
)

optimizer.apply_gradients(
    zip(
        gradients,
        model.trainable_variables,
    )
)

مراحل:

1. اجرای Forward Pass
2. محاسبه Loss
3. محاسبه Gradient
4. به‌روزرسانی وزن‌ها

Keras در model.fit این مراحل را به‌صورت داخلی انجام می‌دهد.

پیش‌نیازهای نصب TensorFlow

برای این آموزش به موارد زیر نیاز دارید:

• Python سازگار با نسخه TensorFlow
• pip
• محیط مجازی
• حداقل چند گیگابایت فضای خالی
• آشنایی مقدماتی با Python
• GPU اختیاری

پیش از نصب، نسخه‌های پشتیبانی‌شده Python و روش نصب مناسب سیستم‌عامل را در راهنمای رسمی نصب TensorFlow بررسی کنید؛ زیرا سازگاری نسخه‌ها و روش نصب GPU ممکن است تغییر کند.

مرحله اول: ساخت پروژه

mkdir tensorflow-sentiment-project
cd tensorflow-sentiment-project

ساخت محیط مجازی در Linux و macOS:

python3 -m venv .venv
source .venv/bin/activate

در Windows PowerShell:

python -m venv .venv
.venv\Scripts\Activate.ps1

به‌روزرسانی pip:

python -m pip install --upgrade pip

مرحله دوم: نصب TensorFlow

برای نصب نسخه معمول:

pip install tensorflow

برای نصب CPU-only در محیط‌های پشتیبانی‌شده می‌توانید دستور ارائه‌شده در مستندات رسمی را بررسی کنید:

pip install tensorflow-cpu

برای GPU، دستور و پیش‌نیازها به سیستم‌عامل و سخت‌افزار وابسته‌اند. دستور موجود در صفحه رسمی نصب را متناسب با محیط خود اجرا کنید.

فایل requirements.txt:

tensorflow
numpy

نصب:

pip install -r requirements.txt

مرحله سوم: بررسی نصب

فایل check_tensorflow.py:

import tensorflow as tf

print(
    "TensorFlow version:",
    tf.__version__,
)

print(
    "Eager execution:",
    tf.executing_eagerly(),
)

print(
    "Physical devices:",
    tf.config.list_physical_devices(),
)

print(
    "GPU devices:",
    tf.config.list_physical_devices(
        "GPU"
    ),
)

اجرا:

python check_tensorflow.py

اگر فهرست GPU خالی باشد:

GPU devices: []

TensorFlow از CPU استفاده خواهد کرد.

انتخاب Device در TensorFlow

TensorFlow معمولاً Device مناسب را به‌صورت خودکار انتخاب می‌کند.

برای مشاهده محل اجرای عملیات:

import tensorflow as tf

with tf.device("/CPU:0"):
    a = tf.constant(
        [[1.0, 2.0]]
    )

    b = tf.constant(
        [[3.0], [4.0]]
    )

    result = tf.matmul(a, b)

print(result)

در پروژه‌های معمول بهتر است مدیریت Device را به TensorFlow بسپارید، مگر اینکه دلیل مشخصی برای انتخاب دستی داشته باشید.

tf.data چیست؟

tf.data ابزاری برای ساخت Pipeline داده است.

با آن می‌توانید:

• داده را به Batch تقسیم کنید.
• ترتیب داده را Shuffle کنید.
• Transform اجرا کنید.
• داده را از فایل بخوانید.
• داده را به‌صورت موازی آماده کنید.
• Pipeline را Prefetch کنید.
• Datasetهای بزرگ را مرحله‌ای بخوانید.

مثال:

import tensorflow as tf

features = tf.constant(
    [
        [0.1, 0.2],
        [0.4, 0.7],
        [0.9, 0.3],
        [0.5, 0.8],
    ]
)

labels = tf.constant(
    [0, 1, 1, 0]
)

dataset = tf.data.Dataset.from_tensor_slices(
    (
        features,
        labels,
    )
)

dataset = (
    dataset
    .shuffle(
        buffer_size=4
    )
    .batch(2)
    .prefetch(
        tf.data.AUTOTUNE
    )
)

for batch_features, batch_labels in dataset:
    print(batch_features)
    print(batch_labels)

Batch، Shuffle و Prefetch

Batch

داده‌ها را گروه‌بندی می‌کند:

dataset.batch(32)

Shuffle

ترتیب نمونه‌ها را تغییر می‌دهد:

dataset.shuffle(
    buffer_size=1000
)

Prefetch

هم‌زمان با اجرای مدل، Batch بعدی را آماده می‌کند:

dataset.prefetch(
    tf.data.AUTOTUNE
)

ترتیب معمول:

dataset = (
    dataset
    .shuffle(1000)
    .batch(32)
    .prefetch(
        tf.data.AUTOTUNE
    )
)

داده Validation و Test معمولاً به Shuffle نیاز ندارند.

ساخت Dataset اختصاصی از CSV

dataset = tf.data.experimental.make_csv_dataset(
    file_pattern="data.csv",
    batch_size=32,
    label_name="label",
    num_epochs=1,
    shuffle=True,
)

برای پروژه واقعی باید موارد زیر را بررسی کنید:

• نوع ستون‌ها
• داده خالی
• مقادیر خارج از محدوده
• ستون Label
• داده تکراری
• تقسیم Train و Validation
• Leakage میان داده‌ها

روش‌های ساخت مدل در Keras

سه روش اصلی وجود دارد:

1. Sequential API
2. Functional API
3. Model Subclassing

Sequential API

برای مدل‌هایی مناسب است که لایه‌ها به‌ترتیب پشت سر هم قرار می‌گیرند:

from tensorflow import keras
from tensorflow.keras import layers

model = keras.Sequential(
    [
        layers.Input(
            shape=(20,)
        ),
        layers.Dense(
            64,
            activation="relu",
        ),
        layers.Dropout(0.2),
        layers.Dense(
            1,
            activation="sigmoid",
        ),
    ]
)

مزایا:

• کد کوتاه
• مناسب مدل‌های ساده
• خوانایی خوب
• مناسب آموزش مقدماتی

محدودیت:

• برای چند ورودی، چند خروجی و معماری‌های شاخه‌ای کافی نیست.

Functional API

Functional API برای معماری‌های پیچیده‌تر مناسب است:

from tensorflow import keras
from tensorflow.keras import layers

inputs = keras.Input(
    shape=(20,),
    name="features",
)

x = layers.Dense(
    64,
    activation="relu",
)(inputs)

x = layers.Dropout(0.2)(x)

outputs = layers.Dense(
    1,
    activation="sigmoid",
    name="prediction",
)(x)

model = keras.Model(
    inputs=inputs,
    outputs=outputs,
)

Functional API از موارد زیر پشتیبانی می‌کند:

• چند ورودی
• چند خروجی
• شاخه‌های موازی
• اتصال‌های Residual
• مدل‌های اشتراکی
• معماری‌های غیرخطی

Model Subclassing

در این روش یک کلاس اختصاصی می‌سازید:

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers


class CustomClassifier(
    keras.Model
):
    def __init__(self):
        super().__init__()

        self.hidden = layers.Dense(
            64,
            activation="relu",
        )

        self.dropout = layers.Dropout(
            0.2
        )

        self.output_layer = layers.Dense(
            1,
            activation="sigmoid",
        )

    def call(
        self,
        inputs,
        training=False,
    ):
        x = self.hidden(inputs)

        x = self.dropout(
            x,
            training=training,
        )

        return self.output_layer(x)

Subclassing کنترل بیشتری دارد، اما مشاهده و ذخیره معماری می‌تواند نیازمند دقت بیشتری باشد.

پروژه عملی: تحلیل احساسات دیدگاه‌ها

در این پروژه از دیتاست IMDB استفاده می‌کنیم. هر دیدگاه دارای یک Label است:

0 = Negative
1 = Positive

داده‌ها از قبل به دنباله‌ای از شناسه واژه‌ها تبدیل شده‌اند.

معماری مدل:

Token IDs
→ Embedding
→ Global Average Pooling
→ Dense
→ Dropout
→ Sigmoid

تنظیمات پروژه

MAX_WORDS = 10000
SEQUENCE_LENGTH = 256
EMBEDDING_DIM = 128
BATCH_SIZE = 64
EPOCHS = 15

MAX_WORDS

تنها ده هزار واژه پرتکرار دیتاست استفاده می‌شوند.

SEQUENCE_LENGTH

هر دیدگاه به طول ثابت ۲۵۶ Token تبدیل می‌شود.

• متن کوتاه Padding می‌شود.
• متن بلند Truncate می‌شود.

EMBEDDING_DIM

هر Token به یک بردار ۱۲۸بعدی تبدیل می‌شود.

مرحله چهارم: دریافت دیتاست IMDB

from tensorflow import keras

MAX_WORDS = 10000

(
    (x_train, y_train),
    (x_test, y_test),
) = keras.datasets.imdb.load_data(
    num_words=MAX_WORDS
)

print(
    "Train samples:",
    len(x_train),
)

print(
    "Test samples:",
    len(x_test),
)

print(
    "First encoded review:",
    x_train[0][:20],
)

print(
    "First label:",
    y_train[0],
)

متن به شکل عددی نمایش داده می‌شود:

[1, 14, 22, 16, ...]

هر عدد شناسه یک واژه است.

Padding دنباله‌ها

شبکه برای ساخت Batch به ورودی‌های هم‌اندازه نیاز دارد:

SEQUENCE_LENGTH = 256

x_train = keras.utils.pad_sequences(
    x_train,
    maxlen=SEQUENCE_LENGTH,
    padding="post",
    truncating="post",
)

x_test = keras.utils.pad_sequences(
    x_test,
    maxlen=SEQUENCE_LENGTH,
    padding="post",
    truncating="post",
)

print(x_train.shape)
print(x_test.shape)

خروجی:

(25000, 256)
(25000, 256)

Embedding چیست؟

لایه Embedding هر شناسه واژه را به یک بردار قابل آموزش تبدیل می‌کند:

layers.Embedding(
    input_dim=MAX_WORDS,
    output_dim=128,
    mask_zero=True,
)

ورودی:

[14, 22, 16]

خروجی تقریبی:

3 Token × 128 Feature

Embedding در طول آموزش تنظیم می‌شود تا واژه‌های مرتبط نمایش عددی مناسب‌تری پیدا کنند.

GlobalAveragePooling1D چیست؟

خروجی Embedding برای هر Token یک بردار دارد. GlobalAveragePooling1D میانگین بردارهای Tokenها را محاسبه و یک بردار ثابت برای کل متن ایجاد می‌کند.

layers.GlobalAveragePooling1D()

این روش ساده است و ترتیب دقیق واژه‌ها را مانند Transformer یا RNN مدل نمی‌کند، اما برای آموزش مفاهیم پایه، سبک و قابل اجرا است.

مرحله پنجم: ساخت مدل

from tensorflow import keras
from tensorflow.keras import layers

model = keras.Sequential(
    [
        layers.Input(
            shape=(SEQUENCE_LENGTH,)
        ),
        layers.Embedding(
            input_dim=MAX_WORDS,
            output_dim=128,
            mask_zero=True,
            name="embedding",
        ),
        layers.GlobalAveragePooling1D(),
        layers.Dense(
            64,
            activation="relu",
        ),
        layers.Dropout(0.3),
        layers.Dense(
            1,
            activation="sigmoid",
        ),
    ],
    name="imdb_sentiment_classifier",
)

model.summary()

خروجی model.summary() شامل این اطلاعات است:

• نام لایه
• Shape خروجی
• تعداد پارامترها
• پارامترهای قابل آموزش
• پارامترهای غیرقابل آموزش

چرا خروجی Sigmoid است؟

مسئله ما دودویی است:

Negative یا Positive

لایه آخر یک مقدار میان صفر و یک تولید می‌کند:

layers.Dense(
    1,
    activation="sigmoid",
)

تفسیر ساده:

کمتر از 0.5 → Negative
بزرگ‌تر یا مساوی 0.5 → Positive

آستانه ۰٫۵ همیشه بهترین انتخاب نیست و در پروژه واقعی باید با داده Validation تنظیم شود.

Compile کردن مدل

model.compile(
    optimizer=keras.optimizers.Adam(
        learning_rate=1e-3
    ),
    loss=keras.losses.BinaryCrossentropy(),
    metrics=[
        keras.metrics.BinaryAccuracy(
            name="accuracy"
        ),
        keras.metrics.AUC(
            name="auc"
        ),
    ],
)

سه بخش اصلی:

Optimizer

keras.optimizers.Adam()

وزن‌ها را بر اساس Gradient به‌روزرسانی می‌کند.

Loss

keras.losses.BinaryCrossentropy()

برای طبقه‌بندی دودویی استفاده می‌شود.

Metrics

accuracy
auc

این معیارها برای مشاهده عملکرد مدل استفاده می‌شوند و مستقیماً نقش Loss را ندارند.

Callback چیست؟

Callback به شما اجازه می‌دهد در مراحل مختلف آموزش عملی انجام دهید.

کاربردها:

• توقف زودهنگام
• ذخیره بهترین مدل
• ثبت Log
• تغییر Learning Rate
• ساخت نمودار با TensorBoard
• توقف در صورت NaN
• اجرای کد سفارشی در پایان Epoch

فهرست Callbackهای موجود در مستندات TensorFlow ارائه شده است.

EarlyStopping

اگر Validation Loss برای چند Epoch بهبود پیدا نکند، آموزش متوقف می‌شود:

early_stopping = (
    keras.callbacks.EarlyStopping(
        monitor="val_loss",
        patience=3,
        restore_best_weights=True,
        verbose=1,
    )
)

restore_best_weights=True باعث می‌شود وزن‌های بهترین Epoch بازگردانده شوند.

ModelCheckpoint

بهترین مدل را ذخیره می‌کند:

model_checkpoint = (
    keras.callbacks.ModelCheckpoint(
        filepath=(
            "checkpoints/"
            "best_sentiment.keras"
        ),
        monitor="val_loss",
        save_best_only=True,
        verbose=1,
    )
)

طبق مستندات ModelCheckpoint، این Callback می‌تواند مدل یا وزن‌ها را در فواصل مشخص و بر اساس معیار انتخابی ذخیره کند.

ReduceLROnPlateau

در صورت متوقف‌شدن بهبود، Learning Rate را کاهش می‌دهد:

reduce_learning_rate = (
    keras.callbacks.ReduceLROnPlateau(
        monitor="val_loss",
        factor=0.5,
        patience=1,
        min_lr=1e-6,
        verbose=1,
    )
)

TensorBoard

برای ثبت نمودارهای آموزش:

from datetime import datetime

log_directory = (
    "logs/fit/"
    + datetime.now().strftime(
        "%Y%m%d-%H%M%S"
    )
)

tensorboard_callback = (
    keras.callbacks.TensorBoard(
        log_dir=log_directory,
        histogram_freq=1,
    )
)

TensorBoard می‌تواند معیارها، Graph، Histogram وزن‌ها و اطلاعات آموزش را نمایش دهد. جزئیات آن در مستندات TensorBoard Callback آمده است.

مرحله ششم: آموزش مدل

history = model.fit(
    x_train,
    y_train,
    validation_split=0.2,
    epochs=EPOCHS,
    batch_size=BATCH_SIZE,
    callbacks=[
        early_stopping,
        model_checkpoint,
        reduce_learning_rate,
        tensorboard_callback,
        keras.callbacks.TerminateOnNaN(),
    ],
    verbose=1,
)

پارامترها:

• validation_split=0.2: بیست درصد داده Train برای Validation
• epochs: حداکثر تعداد Epoch
• batch_size: تعداد نمونه در هر Batch
• callbacks: ابزارهای کنترل آموزش
• verbose: نحوه نمایش پیشرفت

Train، Validation و Test

Train

برای محاسبه Gradient و تغییر وزن‌ها استفاده می‌شود.

Validation

در طول آموزش برای بررسی عملکرد مدل روی داده دیده‌نشده استفاده می‌شود.

Test

پس از پایان انتخاب و تنظیم مدل برای ارزیابی نهایی استفاده می‌شود.

نباید بر اساس نتیجه Test بارها مدل را تنظیم کنید؛ زیرا در این صورت Test به‌صورت غیرمستقیم وارد فرایند انتخاب مدل می‌شود.

مرحله هفتم: ارزیابی مدل

test_metrics = model.evaluate(
    x_test,
    y_test,
    batch_size=BATCH_SIZE,
    return_dict=True,
    verbose=1,
)

for metric_name, metric_value in (
    test_metrics.items()
):
    print(
        metric_name,
        round(
            float(metric_value),
            4,
        ),
    )

خروجی ممکن است شامل این موارد باشد:

loss
accuracy
auc

اعداد دقیق به نسخه کتابخانه، Seed، سخت‌افزار و روند آموزش بستگی دارند.

مشاهده تاریخچه آموزش

شیء history مقدار معیارها را نگه می‌دارد:

print(
    history.history.keys()
)

برای رسم نمودار:

import matplotlib.pyplot as plt

training_loss = (
    history.history["loss"]
)

validation_loss = (
    history.history["val_loss"]
)

epochs_range = range(
    1,
    len(training_loss) + 1,
)

plt.plot(
    epochs_range,
    training_loss,
    label="Train Loss",
)

plt.plot(
    epochs_range,
    validation_loss,
    label="Validation Loss",
)

plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.tight_layout()
plt.show()

برای استفاده از Matplotlib:

pip install matplotlib

اجرای TensorBoard

در پوشه پروژه:

tensorboard --logdir logs

سپس آدرس زیر را باز کنید:

http://localhost:6006

در TensorBoard می‌توانید روند موارد زیر را مشاهده کنید:

• Train Loss
• Validation Loss
• Accuracy
• AUC
• Learning Rate
• Graph مدل
• Histogram وزن‌ها

مرحله هشتم: ذخیره مدل

ذخیره مدل کامل:

model.save(
    "sentiment_model.keras"
)

فرمت .keras می‌تواند معماری، وزن‌ها و اطلاعات موردنیاز برای بارگذاری مدل را نگه دارد.

راهنمای رسمی روش‌های ذخیره در صفحه ذخیره و بارگذاری مدل TensorFlow ارائه شده است.

بارگذاری مدل

from tensorflow import keras

loaded_model = (
    keras.models.load_model(
        "sentiment_model.keras"
    )
)

loaded_model.summary()

ارزیابی مجدد:

loaded_metrics = loaded_model.evaluate(
    x_test,
    y_test,
    return_dict=True,
    verbose=0,
)

print(loaded_metrics)

ذخیره فقط وزن‌ها

model.save_weights(
    "sentiment_model.weights.h5"
)

برای بارگذاری وزن‌ها باید همان معماری ساخته شود:

new_model = build_model()

new_model.load_weights(
    "sentiment_model.weights.h5"
)

اگر ساختار مدل تغییر کند، وزن‌ها ممکن است با معماری جدید سازگار نباشند.

مرحله نهم: پیش‌بینی روی داده Test

sample_index = 0

sample = x_test[
    sample_index:
    sample_index + 1
]

actual_label = int(
    y_test[sample_index]
)

probability = float(
    model.predict(
        sample,
        verbose=0,
    )[0][0]
)

predicted_label = int(
    probability >= 0.5
)

print(
    "Probability:",
    round(
        probability,
        4,
    ),
)

print(
    "Predicted label:",
    predicted_label,
)

print(
    "Actual label:",
    actual_label,
)

تبدیل شناسه واژه‌ها به متن

دیتاست IMDB از Offset برای شناسه‌های ویژه استفاده می‌کند:

word_index = (
    keras.datasets.imdb
    .get_word_index()
)

reverse_word_index = {
    index + 3: word
    for word, index in (
        word_index.items()
    )
}

reverse_word_index[0] = "<PAD>"
reverse_word_index[1] = "<START>"
reverse_word_index[2] = "<OOV>"
reverse_word_index[3] = "<UNUSED>"

تابع Decode:

def decode_review(
    encoded_review,
) -> str:
    words = [
        reverse_word_index.get(
            int(token_id),
            "<UNKNOWN>",
        )
        for token_id in encoded_review
        if int(token_id) != 0
    ]

    return " ".join(words)

استفاده:

print(
    decode_review(
        x_test[0]
    )
)

پیش‌بینی متن دلخواه

برای استفاده از متن جدید باید همان Tokenization و Vocabulary زمان آموزش را به کار ببریم.

نمونه ساده برای متن انگلیسی:

import re
import numpy as np

word_index = (
    keras.datasets.imdb
    .get_word_index()
)


def encode_review(
    text: str,
) -> np.ndarray:
    tokens = re.findall(
        r"[a-z']+",
        text.lower(),
    )

    encoded_tokens = [1]

    for token in tokens:
        original_index = (
            word_index.get(token)
        )

        if original_index is None:
            encoded_tokens.append(2)
            continue

        dataset_index = (
            original_index + 3
        )

        if dataset_index >= MAX_WORDS:
            encoded_tokens.append(2)
        else:
            encoded_tokens.append(
                dataset_index
            )

    return keras.utils.pad_sequences(
        [encoded_tokens],
        maxlen=SEQUENCE_LENGTH,
        padding="post",
        truncating="post",
    )

پیش‌بینی:

review = (
    "The story was engaging and "
    "the acting was excellent."
)

encoded_review = encode_review(
    review
)

probability = float(
    model.predict(
        encoded_review,
        verbose=0,
    )[0][0]
)

sentiment = (
    "Positive"
    if probability >= 0.5
    else "Negative"
)

print(
    {
        "sentiment": sentiment,
        "probability": round(
            probability,
            4,
        ),
    }
)

این Tokenizer برای آموزش عملی ساده‌سازی شده است. در پروژه واقعی باید Preprocessing دقیق و یکسانی برای Train و Inference تعریف و همراه مدل نگهداری کنید.

کد کامل پروژه TensorFlow

فایل train_sentiment.py:

import os
import random
import re
from datetime import datetime

import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

RANDOM_SEED = 42
MAX_WORDS = 10000
SEQUENCE_LENGTH = 256
EMBEDDING_DIM = 128
BATCH_SIZE = 64
EPOCHS = 15

MODEL_PATH = "sentiment_model.keras"
CHECKPOINT_PATH = (
    "checkpoints/"
    "best_sentiment.keras"
)


def set_seed(seed: int) -> None:
    os.environ[
        "PYTHONHASHSEED"
    ] = str(seed)

    random.seed(seed)
    np.random.seed(seed)
    tf.random.set_seed(seed)


def load_and_prepare_data():
    (
        (x_train, y_train),
        (x_test, y_test),
    ) = keras.datasets.imdb.load_data(
        num_words=MAX_WORDS
    )

    x_train = keras.utils.pad_sequences(
        x_train,
        maxlen=SEQUENCE_LENGTH,
        padding="post",
        truncating="post",
    )

    x_test = keras.utils.pad_sequences(
        x_test,
        maxlen=SEQUENCE_LENGTH,
        padding="post",
        truncating="post",
    )

    return (
        x_train,
        y_train,
        x_test,
        y_test,
    )


def build_model() -> keras.Model:
    model = keras.Sequential(
        [
            layers.Input(
                shape=(SEQUENCE_LENGTH,)
            ),
            layers.Embedding(
                input_dim=MAX_WORDS,
                output_dim=EMBEDDING_DIM,
                mask_zero=True,
                name="embedding",
            ),
            layers.GlobalAveragePooling1D(),
            layers.Dense(
                64,
                activation="relu",
            ),
            layers.Dropout(0.3),
            layers.Dense(
                1,
                activation="sigmoid",
            ),
        ],
        name=(
            "imdb_sentiment_classifier"
        ),
    )

    model.compile(
        optimizer=(
            keras.optimizers.Adam(
                learning_rate=1e-3
            )
        ),
        loss=(
            keras.losses
            .BinaryCrossentropy()
        ),
        metrics=[
            keras.metrics.BinaryAccuracy(
                name="accuracy"
            ),
            keras.metrics.AUC(
                name="auc"
            ),
        ],
    )

    return model


def build_callbacks():
    os.makedirs(
        "checkpoints",
        exist_ok=True,
    )

    log_directory = (
        "logs/fit/"
        + datetime.now().strftime(
            "%Y%m%d-%H%M%S"
        )
    )

    return [
        keras.callbacks.EarlyStopping(
            monitor="val_loss",
            patience=3,
            restore_best_weights=True,
            verbose=1,
        ),
        keras.callbacks.ModelCheckpoint(
            filepath=CHECKPOINT_PATH,
            monitor="val_loss",
            save_best_only=True,
            verbose=1,
        ),
        keras.callbacks.ReduceLROnPlateau(
            monitor="val_loss",
            factor=0.5,
            patience=1,
            min_lr=1e-6,
            verbose=1,
        ),
        keras.callbacks.TensorBoard(
            log_dir=log_directory,
            histogram_freq=1,
        ),
        keras.callbacks.TerminateOnNaN(),
    ]


def encode_review(
    text: str,
    word_index: dict[str, int],
) -> np.ndarray:
    tokens = re.findall(
        r"[a-z']+",
        text.lower(),
    )

    encoded_tokens = [1]

    for token in tokens:
        original_index = (
            word_index.get(token)
        )

        if original_index is None:
            encoded_tokens.append(2)
            continue

        dataset_index = (
            original_index + 3
        )

        if dataset_index >= MAX_WORDS:
            encoded_tokens.append(2)
        else:
            encoded_tokens.append(
                dataset_index
            )

    return keras.utils.pad_sequences(
        [encoded_tokens],
        maxlen=SEQUENCE_LENGTH,
        padding="post",
        truncating="post",
    )


def predict_text(
    model: keras.Model,
    text: str,
    word_index: dict[str, int],
) -> dict:
    encoded_text = encode_review(
        text=text,
        word_index=word_index,
    )

    probability = float(
        model.predict(
            encoded_text,
            verbose=0,
        )[0][0]
    )

    label = (
        "positive"
        if probability >= 0.5
        else "negative"
    )

    return {
        "label": label,
        "positive_probability": round(
            probability,
            4,
        ),
    }


def main():
    set_seed(RANDOM_SEED)

    print(
        "TensorFlow version:",
        tf.__version__,
    )

    print(
        "GPU devices:",
        tf.config.list_physical_devices(
            "GPU"
        ),
    )

    (
        x_train,
        y_train,
        x_test,
        y_test,
    ) = load_and_prepare_data()

    print(
        "Train shape:",
        x_train.shape,
    )

    print(
        "Test shape:",
        x_test.shape,
    )

    model = build_model()

    model.summary()

    history = model.fit(
        x_train,
        y_train,
        validation_split=0.2,
        epochs=EPOCHS,
        batch_size=BATCH_SIZE,
        callbacks=build_callbacks(),
        verbose=1,
    )

    test_metrics = model.evaluate(
        x_test,
        y_test,
        batch_size=BATCH_SIZE,
        return_dict=True,
        verbose=1,
    )

    print(
        "Test metrics:",
        {
            key: round(
                float(value),
                4,
            )
            for key, value in (
                test_metrics.items()
            )
        },
    )

    model.save(MODEL_PATH)

    print(
        "Model saved to:",
        MODEL_PATH,
    )

    word_index = (
        keras.datasets.imdb
        .get_word_index()
    )

    example_text = (
        "The story was engaging and "
        "the acting was excellent."
    )

    result = predict_text(
        model=model,
        text=example_text,
        word_index=word_index,
    )

    print(
        "Custom prediction:",
        result,
    )

    print(
        "Completed epochs:",
        len(
            history.history["loss"]
        ),
    )


if __name__ == "__main__":
    main()

اجرا:

python train_sentiment.py

بهبود مدل تحلیل احساسات

مدل نمونه ساده است. برای بهبود آن می‌توانید این روش‌ها را آزمایش کنید:

• استفاده از TextVectorization
• ساخت Vocabulary اختصاصی
• استفاده از داده بیشتر
• پاک‌سازی بهتر متن
• استفاده از Bidirectional LSTM
• استفاده از CNN یک‌بعدی
• استفاده از Attention
• استفاده از مدل Transformer ازپیش‌آموزش‌دیده
• تنظیم Embedding Dimension
• تنظیم Sequence Length
• تنظیم Learning Rate
• ارزیابی Threshold
• بررسی داده‌های اشتباه طبقه‌بندی‌شده
• استفاده از مدل چندزبانه برای فارسی

استفاده از TextVectorization

در یک پروژه جدید بهتر است Preprocessing داخل مدل یا Pipeline ذخیره شود.

نمونه:

from tensorflow.keras import layers

vectorizer = layers.TextVectorization(
    max_tokens=20000,
    output_mode="int",
    output_sequence_length=256,
)

vectorizer.adapt(
    training_text_dataset
)

سپس می‌توان مدل را مستقیماً با متن خام ساخت:

inputs = keras.Input(
    shape=(),
    dtype=tf.string,
)

x = vectorizer(inputs)

x = layers.Embedding(
    input_dim=20000,
    output_dim=128,
    mask_zero=True,
)(x)

x = layers.GlobalAveragePooling1D()(x)

x = layers.Dense(
    64,
    activation="relu",
)(x)

outputs = layers.Dense(
    1,
    activation="sigmoid",
)(x)

model = keras.Model(
    inputs=inputs,
    outputs=outputs,
)

مزیت این روش آن است که Preprocessing همراه Graph مدل قرار می‌گیرد و احتمال تفاوت میان آموزش و Inference کاهش می‌یابد.

مدل تحلیل احساسات فارسی

دیتاست IMDB انگلیسی است. برای ساخت مدل فارسی باید:

1. دیتاست فارسی دارای Label تهیه کنید.
2. داده‌ها را پاک‌سازی کنید.
3. Train، Validation و Test جدا بسازید.
4. TextVectorization را با متن فارسی Adapt کنید.
5. طول متن و اندازه Vocabulary را اندازه‌گیری کنید.
6. Baseline ساده بسازید.
7. معیارهایی مانند F1 را بررسی کنید.
8. مدل را روی متن رسمی و محاوره‌ای آزمایش کنید.
9. نیم‌فاصله، اعداد و نشانه‌ها را مدیریت کنید.
10. خروجی‌های نامطمئن را برای بررسی انسانی نگه دارید.

نمونه برچسب:

0 = منفی
1 = مثبت

برای کاربردهای پیچیده‌تر ممکن است به برچسب خنثی نیز نیاز داشته باشید:

0 = منفی
1 = خنثی
2 = مثبت

در این حالت لایه خروجی سه واحد خواهد داشت:

layers.Dense(
    3,
    activation="softmax",
)

Loss:

keras.losses.SparseCategoricalCrossentropy()

Overfitting چیست؟

اگر مدل روی داده Train بسیار خوب و روی Validation ضعیف عمل کند، احتمال Overfitting وجود دارد.

نشانه‌ها:

• Train Loss کاهش می‌یابد.
• Validation Loss افزایش می‌یابد.
• Train Accuracy رشد می‌کند.
• Validation Accuracy متوقف می‌شود.

راهکارهای احتمالی:

• EarlyStopping
• Dropout
• داده بیشتر
• مدل کوچک‌تر
• Weight Regularization
• کاهش تعداد Epoch
• بهبود تقسیم داده
• حذف داده‌های تکراری
• Data Augmentation در کاربردهای سازگار

Underfitting چیست؟

Underfitting زمانی رخ می‌دهد که مدل حتی روی داده Train نیز عملکرد مناسبی ندارد.

دلایل احتمالی:

• مدل بیش از حد ساده
• آموزش ناکافی
• Learning Rate نامناسب
• Preprocessing نادرست
• داده نامناسب
• Featureهای ناکافی
• Loss نامتناسب

Accuracy همیشه کافی نیست

در داده نامتوازن، Accuracy می‌تواند گمراه‌کننده باشد.

فرض کنید ۹۵ درصد نمونه‌ها منفی هستند. مدلی که همیشه «منفی» پیش‌بینی کند، Accuracy برابر ۹۵ درصد دارد، اما کاربردی نیست.

معیارهای دیگر:

• Precision
• Recall
• F1 Score
• AUC
• Confusion Matrix
• False Positive Rate
• False Negative Rate

معیار مناسب باید بر اساس کاربرد واقعی انتخاب شود.

استفاده از مدل آماده یا آموزش مدل اختصاصی؟

مدل اختصاصی با TensorFlow مناسب است اگر:

• داده برچسب‌خورده مناسب دارید.
• مسئله خاص و محدود است.
• کنترل معماری برایتان مهم است.
• تیم یادگیری ماشین دارید.
• نیازمند آموزش یا فاین تیونینگ هستید.
• سخت‌افزار مناسب در دسترس است.

مدل آماده و API مناسب است اگر:

• می‌خواهید سریع محصول بسازید.
• داده آموزشی کافی ندارید.
• مدل عمومی نیاز شما را پوشش می‌دهد.
• نمی‌خواهید GPU مدیریت کنید.
• به چند مدل مختلف نیاز دارید.
• هدف اصلی ساخت اپلیکیشن است.
• میزان مصرف متغیر است.

چه زمانی از API درواره استفاده کنیم؟

اگر هدفتان اضافه‌کردن قابلیت‌هایی مانند موارد زیر است، معمولاً لازم نیست مدل را از ابتدا با TensorFlow آموزش دهید:

• تولید متن
• خلاصه‌سازی
• ترجمه
• پرسش و پاسخ
• تولید کد
• تحلیل تصویر
• استخراج اطلاعات
• ساخت چت‌بات
• ساخت Agent
• تولید تصویر
• پردازش صوت

درواره دسترسی API به مدل‌های هوش مصنوعی را فراهم می‌کند. با این روش نیازی به دانلود وزن‌های بزرگ، مدیریت GPU و آماده‌سازی زیرساخت Inference ندارید.

نمونه اتصال پایتون به API درواره

نصب:

pip install openai python-dotenv

فایل .env:

DARVAREH_API_KEY=YOUR_DARVAREH_API_KEY
DARVAREH_MODEL_ID=YOUR_MODEL_ID

کد:

import os

from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

api_key = os.getenv(
    "DARVAREH_API_KEY"
)

model_id = os.getenv(
    "DARVAREH_MODEL_ID"
)

if not api_key:
    raise RuntimeError(
        "DARVAREH_API_KEY تنظیم نشده است."
    )

if not model_id:
    raise RuntimeError(
        "DARVAREH_MODEL_ID تنظیم نشده است."
    )

client = OpenAI(
    api_key=api_key,
    base_url="https://api.darvareh.ir/v1",
)

response = client.chat.completions.create(
    model=model_id,
    messages=[
        {
            "role": "system",
            "content": (
                "شما یک دستیار فارسی دقیق هستید."
            ),
        },
        {
            "role": "user",
            "content": (
                "این نظر را خلاصه و "
                "احساس کلی آن را مشخص کن: "
                "رابط برنامه مناسب بود اما "
                "سرعت پاسخ‌گویی باید بهتر شود."
            ),
        },
    ],
    temperature=0.1,
    max_tokens=400,
)

print(
    response
    .choices[0]
    .message
    .content
)

Model ID و قیمت مدل‌های موجود را از صفحه مدل‌های درواره دریافت کنید.

مقایسه TensorFlow و API درواره

می‌توان از معماری ترکیبی نیز استفاده کرد:

مدل کوچک TensorFlow
→ پردازش یا طبقه‌بندی اولیه
→ API درواره
→ تحلیل یا تولید پاسخ پیشرفته

خطاهای رایج TensorFlow

خطای No module named tensorflow

محیط مجازی را فعال و TensorFlow را نصب کنید:

pip install tensorflow

بررسی:

pip show tensorflow

GPU شناسایی نمی‌شود

این دستور را اجرا کنید:

tf.config.list_physical_devices(
    "GPU"
)

سپس بررسی کنید:

• سخت‌افزار پشتیبانی می‌شود.
• Driver مناسب نصب است.
• نسخه‌های موردنیاز سازگارند.
• روش نصب رسمی سیستم‌عامل استفاده شده است.
• TensorFlow داخل همان محیط مجازی اجرا می‌شود.

خطای Shape

نمونه:

Input shape is incompatible

Shape ورودی و انتظار مدل را مقایسه کنید:

print(x_train.shape)
print(model.input_shape)

خطای نوع داده

print(x_train.dtype)
print(y_train.dtype)

در صورت نیاز:

x_train = x_train.astype(
    "int32"
)

y_train = y_train.astype(
    "float32"
)

Loss به NaN تبدیل می‌شود

دلایل احتمالی:

• Learning Rate زیاد
• داده دارای NaN
• عملیات عددی ناپایدار
• ورودی خارج از محدوده
• Loss اشتباه

بررسی:

print(
    np.isnan(x_train).any()
)

print(
    np.isinf(x_train).any()
)

Callback زیر نیز آموزش را متوقف می‌کند:

keras.callbacks.TerminateOnNaN()

مدل فقط یک کلاس را پیش‌بینی می‌کند

بررسی کنید:

• داده نامتوازن نباشد.
• Labelها صحیح باشند.
• Threshold مناسب باشد.
• خروجی و Loss با هم سازگار باشند.
• داده Train تنوع کافی داشته باشد.
• مدل بیش از حد ساده نباشد.

مدل ذخیره‌شده بارگذاری نمی‌شود

موارد زیر را بررسی کنید:

• فایل کامل دانلود یا کپی شده است.
• نسخه‌ها سازگار هستند.
• لایه سفارشی نیازمند custom_objects نیست.
• پسوند و فرمت ذخیره درست است.
• فایل وزن با مدل کامل اشتباه نشده است.

چک‌لیست آموزش مدل با TensorFlow

• نسخه Python و TensorFlow سازگارند.
• محیط مجازی فعال است.
• داده Train، Validation و Test جدا هستند.
• داده تکراری میان بخش‌ها وجود ندارد.
• Shape و dtype بررسی شده‌اند.
• Padding و Truncation مشخص هستند.
• مدل با خروجی مسئله سازگار است.
• Loss مناسب انتخاب شده است.
• Metricهای مناسب تعریف شده‌اند.
• EarlyStopping فعال است.
• بهترین مدل ذخیره می‌شود.
• TensorBoard یا Log آموزش فعال است.
• Test فقط برای ارزیابی نهایی استفاده می‌شود.
• Preprocessing برای Train و Inference یکسان است.
• Seed ثبت شده است.
• محدودیت‌های مدل مستند شده‌اند.
• مدل روی داده واقعی آزمایش شده است.

مسیر یادگیری پیشنهادی TensorFlow

مرحله اول: Python و NumPy

• متغیرها
• توابع
• کلاس‌ها
• آرایه NumPy
• Shape
• Indexing
• عملیات ماتریسی

مرحله دوم: TensorFlow پایه

• Tensor
• Variable
• dtype
• Broadcasting
• GradientTape
• tf.function
• Device

مرحله سوم: Keras

• Layer
• Sequential
• Functional API
• compile
• fit
• evaluate
• predict

مرحله چهارم: داده

• tf.data
• Batch
• Shuffle
• Map
• Cache
• Prefetch
• TextVectorization

مرحله پنجم: شبکه‌های عصبی

• Dense
• Activation
• Dropout
• Loss
• Optimizer
• Metric
• Backpropagation

مرحله ششم: پروژه‌های تخصصی

• CNN برای تصویر
• LSTM برای دنباله
• Transformer برای متن
• Autoencoder
• مدل‌های سری زمانی
• Transfer Learning

مرحله هفتم: استقرار

• ذخیره مدل
• ساخت API
• Batch Inference
• مدل موبایل
• مدل مرورگر
• مانیتورینگ کیفیت

پرسش‌های متداول

TensorFlow چیست؟

TensorFlow یک پلتفرم متن‌باز یادگیری ماشین برای کار با Tensor، ساخت و آموزش شبکه عصبی و اجرای مدل در محیط‌های مختلف است.

Keras چیست؟

Keras یک API سطح‌بالا برای ساخت، آموزش، ارزیابی و ذخیره مدل‌های یادگیری عمیق است. در پروژه TensorFlow معمولاً از tf.keras استفاده می‌شود.

آیا TensorFlow برای مبتدیان مناسب است؟

Keras شروع یادگیری TensorFlow را ساده‌تر می‌کند. با این حال، آشنایی با Python، NumPy و مفاهیم پایه یادگیری ماشین ضروری است.

آیا برای TensorFlow به GPU نیاز داریم؟

برای پروژه‌های کوچک و آموزشی، CPU کافی است. آموزش مدل‌های بزرگ‌تر یا پردازش داده حجیم می‌تواند به GPU نیاز داشته باشد.

تفاوت Tensor و NumPy Array چیست؟

Tensor می‌تواند بخشی از Graph محاسباتی باشد، Gradient داشته باشد و روی سخت‌افزارهایی مانند GPU اجرا شود. NumPy عمدتاً برای محاسبات عددی روی CPU استفاده می‌شود.

GradientTape چه کاری انجام می‌دهد؟

عملیات را ثبت می‌کند تا TensorFlow بتواند Gradient متغیرها را نسبت به Loss محاسبه کند.

model.fit چیست؟

model.fit حلقه آموزش Keras را اجرا می‌کند و Batchها، Forward Pass، Loss، Gradient، به‌روزرسانی وزن‌ها و Callbackها را مدیریت می‌کند.

تفاوت model.evaluate و model.predict چیست؟

evaluate عملکرد مدل را با Label و Metric اندازه‌گیری می‌کند. predict فقط خروجی مدل را برای ورودی جدید تولید می‌کند.

بهترین فرمت ذخیره Keras چیست؟

برای ذخیره مدل کامل در پروژه‌های جدید، فرمت .keras انتخاب مناسبی است:

model.save(
    "model.keras"
)

آیا می‌توان TensorFlow را در Google Colab اجرا کرد؟

بله. می‌توانید Notebook بسازید، Runtime مناسب انتخاب کنید و کد TensorFlow را بدون نصب محلی اجرا کنید.

TensorFlow بهتر است یا PyTorch؟

انتخاب به پروژه بستگی دارد. TensorFlow با Keras حلقه آموزش سطح‌بالا و اکوسیستم گسترده‌ای دارد. PyTorch نیز در پژوهش و مدل‌های مدرن بسیار رایج است. یادگیری مفاهیم اصلی مهم‌تر از تعصب روی یک فریم‌ورک است.

آیا برای استفاده از مدل زبانی باید TensorFlow یاد بگیریم؟

اگر فقط می‌خواهید مدل آماده را از طریق API به برنامه متصل کنید، خیر. TensorFlow زمانی اهمیت بیشتری دارد که بخواهید مدل بسازید، آموزش دهید یا رفتار داخلی آن را کنترل کنید.

جمع‌بندی

TensorFlow یکی از مهم‌ترین پلتفرم‌های یادگیری ماشین و یادگیری عمیق است. این فریم‌ورک ابزارهایی برای کار با Tensor، محاسبه Gradient، پردازش داده، ساخت شبکه عصبی، آموزش، ارزیابی و استقرار مدل ارائه می‌کند.

Keras نیز با فراهم‌کردن API سطح‌بالا، بسیاری از مراحل ساخت مدل را ساده می‌کند.

در این آموزش یاد گرفتیم:

• TensorFlow چیست.
• Keras چه تفاوتی با TensorFlow دارد.
• Tensor و Variable چگونه کار می‌کنند.
• GradientTape چیست.
• tf.data چگونه Pipeline داده می‌سازد.
• مدل Sequential و Functional چگونه ساخته می‌شوند.
• مدل تحلیل احساسات چگونه طراحی می‌شود.
• Embedding چه کاربردی دارد.
• مدل با compile و fit چگونه آموزش می‌بیند.
• Callbackهای EarlyStopping، ModelCheckpoint و TensorBoard چگونه استفاده می‌شوند.
• مدل چگونه ارزیابی، ذخیره و بارگذاری می‌شود.
• برای متن جدید چگونه پیش‌بینی انجام می‌شود.
• چه زمانی TensorFlow و چه زمانی API مناسب‌تر است.

اگر هدف شما یادگیری ساخت مدل، پردازش داده یا توسعه شبکه عصبی اختصاصی است، TensorFlow و Keras ابزارهای مناسبی هستند. اگر می‌خواهید بدون مدیریت GPU و آموزش مدل، قابلیت هوش مصنوعی را سریع‌تر به نرم‌افزار خود اضافه کنید، استفاده از API مدل‌های آماده مسیر کوتاه‌تری خواهد بود.

برای شروع استفاده از مدل‌های هوش مصنوعی، در درواره ثبت‌نام کنید، API Key بسازید و مدل مناسب پروژه را از صفحه مدل‌ها انتخاب کنید.

مقالات مرتبط

• آموزش هوش مصنوعی با پایتون و ساخت پروژه واقعی
• Fine-Tuning چیست؟ آموزش LoRA و QLoRA
• راهنمای کامل مدل‌های هوش مصنوعی
• Inference چیست؟ راهنمای اجرای مدل هوش مصنوعی
• Embedding چیست و چه کاربردی دارد؟
• آموزش دریافت API هوش مصنوعی و ساخت API Key
• API هوش مصنوعی چیست؟
• کاهش هزینه API هوش مصنوعی

برای مطالعه شرایط استفاده و محدودیت‌های مسئولیت، صفحه «سلب مسئولیت» را مشاهده کنید.