רובֿ פון אונדז זענען באַקאַנט מיט אַי בילד גענעראַטאָרס ווי סטאַביל דיפיוזשאַן. עס האט שוין געביטן די אינדוסטריע און איז ינקאָרפּערייטיד אין אונדזער לעבן.
אָבער, סטאַביל דיפפוסיאָן מאָדעלס זענען אַזוי פיל מער ווי בילד דור.
עס זענען אַזוי פילע געביטן אין וואָס מיר קענען נוצן זיי.
סטאַביל דיפיוזשאַן מאָדעלס זענען מאַטאַמאַטיקאַל מאָדעלס. און זיי קענען העלפֿן איר צו פאָרשן די דינאַמיק פון טשאַנגינג סיסטעמען איבער צייט.
זיי זענען באזירט אויף דיפיוזשאַן פּראָצעס קאַנסעפּס. דעריבער, איר קענען ונטערזוכן אַ ברייט קייט פון דערשיינונגען. למשל; היץ טראַנסמיסיע, כעמיש ריאַקשאַנז און אינפֿאָרמאַציע פּראַפּאַגיישאַן אין פינאַנציעל מארקפלעצער.
די מאָדעלס זענען גאָר אַדאַפּטאַבאַל. אַזוי, איר קענען פאָרויסזאָגן די צוקונפֿט שטאַט פון אַ סיסטעם באזירט אויף זייַן קראַנט צושטאַנד.
חוץ, איר קענען זען די אַנדערלייינג גשמיות אָדער פינאַנציעל פּרינסאַפּאַלז וואָס רעגירן עס. דער באַגריף איז געווען זייער נוציק אין פילע געביטן. די אַרייַננעמען פיזיק, כעמיע און פינאַנצן.
דערפאר ווילן מיר עס ווייטער אויספארשן. און, מיר ווילן צו געבן איר אַ טוטאָריאַל ווי צו באַן די סטאַביל דיפפוסיאָן מאָדעלס.
ווי זענען סטאַביל דיפיוזשאַן מאָדעלס געקומען וועגן?
דאס האט רוץ צוריק צו די שפּעט 19 יאָרהונדערט.
די מאַטאַמאַטיקאַל ויספאָרשונג פון דיפיוזשאַן פּראַסעסאַז אין ענינים איז ווו סטאַביל דיפפוסיאָן מאָדעלס האָבן זייער אָנהייב. איינער פון די מערסט פאָלקס סטאַביל דיפפוסיאָן מאָדעלס איז די Fokker-Planck יקווייזשאַן.
עס איז געווען ערשטער דערלאנגט אין 1906. די מאָדעלס האָבן יוואַלווד און געווארן מאַדאַפייד דורך צייַט. דעריבער, מיר איצט נוצן זיי אין אַ פאַרשיידנקייַט פון ינדאַסטריז.
וואָס איז די לאָגיק הינטער עס?
אין פּשוט ווערטער, ווי מיר געזאגט, זיי זענען מאַטאַמאַטיקאַל מאָדעלס. אויסערדעם, זיי העלפֿן אונדז צו פאָרשן ווי אַ פאַרמאָג אָדער קוואַנטיטי ספּרעדז איבער צייַט אין אַ סיסטעם.
זיי זענען באזירט אויף די פּרינסאַפּאַלז פון דיפיוזשאַן פּראָצעס. אַזוי, זיי העלפֿן אונדז צו פאָרשן ווי אַ קוואַנטיטי ספּרעדז אַריבער אַ סיסטעם. די פארשפרייטונג איז אַ רעזולטאַט פון ווערייישאַנז אין קאַנסאַנטריישאַן, דרוק אָדער אנדערע פּאַראַמעטערס.
זאל ס געבן אַ פּשוט בייַשפּיל. ימאַדזשאַן איר האָבן אַ קאַנטיינער פול פון פליסיק אין וואָס איר האָט צוגעגעבן אַ פאַרב. דיפיוזשאַן איז געזען דאָ ווען די פאַרב הייבט צו צעשפּרייטן און עמולסיפי אין די פליסיק. באזירט אויף די קעראַקטעריסטיקס פון די פליסיק און פאַרב, סטאַביל דיפפוסיאָן מאָדעלס קענען זיין געוויינט צו פאָרויסזאָגן ווי די פאַרב וועט צעשפּרייטן און מישן איבער צייט.
אין מער קאָמפּליצירט סיסטעמען, ווי פינאַנציעל מארקפלעצער אָדער כעמיש ריאַקשאַנז, די מאָדעלס קענען פאָרויסזאָגן ווי אינפֿאָרמאַציע אָדער אַטריביוץ וועט פאַרשפּרייטן און פּראַל אויף די סיסטעם איבער צייַט. אויסערדעם, גרויס דאַטן קען באַקומען געוויינט צו באַן די מאָדעלס צו מאַכן פּינטלעך פֿאָרויסזאָגן. זיי זענען געבויט מיט מאַטאַמאַטיקאַל פאָרמולאַס וואָס באַשרייַבן די לאַנג-טערמין עוואָלוציע פון די סיסטעם.
פארשטאנד און פאָרויסזאָגן די פּראַפּאַגיישאַן פון זיכער טרייץ אין אַ סיסטעם דורך צייט איז די הויפּט געדאַנק פון די מאָדעלס. עס איז וויכטיק צו געדענקען אַז עקספּערץ אין ספּעשאַלייזד פעלדער נוצן די מאָדעלס.
ווי צו באַן מאָדעלס?
קלייַבן און צוגרייטן דיין דאַטן:
איר מוזן ערשטער קלייַבן און צוגרייטן דיין דאַטן איידער איר קענען אָנהייבן טריינינג דיין מאָדעל. דיין דאַטן קען זיין קלינד און פאָרמאַטטעד. אויך, די פעלנדיק נומערן קען אויך דאַרפֿן צו זיין ילימאַנייטאַד.
אויסקלייַבן אַ מאָדעל אַרקאַטעקטשער
סטאַביל דיפפוסיאָן מאָדעלס קומען אין אַ פאַרשיידנקייַט פון פארמען. עס איז מערסטנס באזירט אויף די Fokker-Planck יקווייזשאַן, די Schrödinger יקווייזשאַן און די מאַסטער יקווייזשאַן. דער מאָדעל וואָס איז בעסטער פּאַסיק פֿאַר דיין באַזונדער סיטואַציע מוזן זיין אויסדערוויילט. אזוי, יעדער פון די מאָדעלס האט אַדוואַנטידזשיז און דיסאַדוואַנטידזשיז.
פאַרלייגן דיין אָנווער פונקציע
עס איז וויכטיק ווייַל עס אַפעקץ ווי געזונט דיין מאָדעל קענען גלייַכן די דאַטן. פֿאַר סטאַביל דיפיוזשאַן מאָדעלס, די דורכשניטלעך סקווערד טעות און די דיווערדזשאַנס פון די קוללבאַקק-לייבלער זענען אָפט אָנווער פאַנגקשאַנז.
באַן דיין מאָדעל
ניצן סטאָטשאַסטיק גראַדיענט אַראָפּגאַנג אָדער אַ ענלעך אַפּטאַמאַזיישאַן צוגאַנג, איר קען אָנהייבן טריינינג דיין מאָדעל נאָך דיפיינינג דיין אָנווער פונקציע.
ונטערזוכן די גענעראַליזאַביליטי פון דיין מאָדעל
איר זאָל קאָנטראָלירן פריש דאַטן נאָך טריינינג דורך קאַמפּערינג עס צו אַ פּראָבע גאַנג פון דאַטן.
סטרויערן די כייפּערפּאַראַמעטערס פון דיין מאָדעל
צו פֿאַרבעסערן די פאָרשטעלונג פון דיין מאָדעל, עקספּערימענט מיט פאַרשידן וואַלועס פון כייפּערפּאַראַמאַטער ווי לערנען קורס, פּעקל גרייס און די נומער פון פאַרבאָרגן לייַערס אין די נעץ.
איבערחזרן די פריערדיקע אַקשאַנז
איר קען דאַרפֿן צו איבערחזרן די פּראַסעסאַז מער ווי אַמאָל צו באַקומען די בעסטער רעזולטאַטן. עס וועט זיין דיפּענדינג אויף די שוועריקייט פון די פּראָבלעם און די קאַליבער פון די דאַטן.
קאָודינג טוטאָריאַל
פּראָגראַממינג שפּראַכן ווי Python, MATLAB, C ++, און R קען אַלע זיין געוויינט צו שאַפֿן סטאַביל דיפפוסיאָן מאָדעלס. די שפּראַך געניצט וועט פאַרלאָזנ אויף די באַזונדער אַפּלאַקיישאַן. עס קען אויך אָפענגען אויף מכשירים און לייברעריז בנימצא פֿאַר דער שפּראַך.
פּיטהאָן איז דער בעסטער ברירה אין דעם פאַל. עס האט שטאַרק לייברעריז ווי NumPy און SciPy פֿאַר נומעריקאַל קאַמפּיאַטיישאַן. עס שטיצט אויך TensorFlow און פּיטאָרטש פֿאַר קריייטינג און טריינינג נעוראַל נעטוואָרקס. דערפאר, עס ווערט אַ גרויס אָפּציע פֿאַר שרייבן סטאַביל דיפוסיאָן מאָדעלס.
בייַשפּיל:
לאָמיר נוצן די דיפיוזשאַן יקווייזשאַן, אַ מאַטאַמאַטיקאַל פאָרמולע וואָס באשרייבט ווי אַ קוואַליטעט אָדער קוואַנטיטי, אַזאַ ווי היץ אָדער די קאַנסאַנטריישאַן פון אַ מאַטעריע, ענדערונגען איבער צייַט אין אַ סיסטעם. די יקווייזשאַן בכלל קוקט ווי דאָס:
∂ו/∂ט = α ∇²ו
די דיפיוזשאַן קאָואַפישאַנט () איז אַ מעזשערמאַנט פון ווי לייכט אַ פאַרמאָג אָדער קוואַנטיטי ספּרעדז דורך אַ סיסטעם.
די לאַפּלאַסיאַן פון ו (2ו) איז אַ באַשרייַבונג פון ווי די פאַרמאָג אָדער קוואַנטיטי ענדערונגען אין רעספּעקט צו פּלאַץ. ווו u איז די פאַרמאָג אָדער קוואַנטיטי זייַענדיק דיפיוזד (למשל טעמפּעראַטור אָדער קאַנסאַנטריישאַן), t איז די דורכפאָר פון צייט, איז די דיפיוזשאַן קאָואַפישאַנט, און איז די דיפיוזשאַן קעסיידערדיק ().
מיר קענען ינסטרומענט עס מיט די Euler אופֿן אין Python.
import numpy as np
# Define the diffusion coefficient
alpha = 0.1
# Define the initial condition (e.g. initial temperature or concentration)
u = np.ones(100)
# Time step
dt = 0.01
# Time-stepping loop
for t in range(1000):
# Compute the spatial derivative
du = np.diff(u)
# Update the value of u
u[1:] = u[1:] + alpha * du * dt
דער קאָד ניצט די Euler טעכניק צו ינסטרומענט די דיפיוזשאַן יקווייזשאַן. עס באשרייבט די סטאַרטינג שטאַט ווי אַ מונדיר ערשט צושטאַנד רעפּריזענטיד דורך אַ מענגע פון אָנעס מיט די פאָרעם פון (100). 0.01 איז געניצט ווי די צייט שריט.
1000 יטעריישאַנז פון די צייט-סטעפּינג שלייף זענען געענדיקט.
עס ניצט די np.diff פֿונקציע, וואָס דיטערמאַנז די חילוק צווישן ארומיקע עלעמענטן. דעריבער, עס קאַמפּיוץ די ספּיישאַל דעריוואַט פון די פאַרמאָג אָדער קוואַנטיטי וואָס איז דיפיוזד. און, עס איז רעפּריזענטיד דורך דו, אין יעדער יטעראַטיאָן.
דערנאָך מיר מערן די ספּיישאַל דעריוואַט מיט די דיפיוזשאַן קאָואַפישאַנט אַלף און די צייט שריט צו דערהייַנטיקן די ווערט פון ו.
א מער קאָמפּליצירט בייַשפּיל
וואָס וואָלט אַ סטאַביל דיפיוזשאַן מאָדעל וואָס בלויז מיטלען סטאַביל היץ דיפיוזשאַן קוק ווי? ווי אַזוי פונקציאָנירן דעם קאָד?
סאַלווינג אַ גאַנג פון פּאַרטיייש דיפערענטשאַל יקווייזשאַנז (PDEs) וואָס דערקלערן ווי היץ ספּרעדז איבער אַ סיסטעם איבער צייַט איז נייטיק. אַזוי, מיר קענען באַן אַ סטאַביל דיפיוזשאַן מאָדעל וואָס רעפּליקייץ די פעסט דיפיוזשאַן פון היץ.
דאָ איז אַ געמעל פון ווי די היץ יקווייזשאַן, אַ PDE וואָס דערקלערט די סטאַביל דיפיוזשאַן פון היץ אין אַ איין-דימענשאַנאַל רוט, קען זיין סאַלווד מיט די ענדלעך חילוק אופֿן:
import numpy as np
import matplotlib.pyplot as plt
# Define the initial conditions
L = 1 # length of the rod
Nx = 10 # number of spatial grid points
dx = L / (Nx - 1) # spatial grid spacing
dt = 0.01 # time step
T = 1 # total time
# Set up the spatial grid
x = np.linspace(0, L, Nx)
# Set up the initial temperature field
T0 = np.zeros(Nx)
T0[0] = 100 # left boundary condition
T0[-1] = 0 # right boundary condition
# Set up the time loop
Tn = T0
for n in range(int(T / dt)):
Tnp1 = np.zeros(Nx)
Tnp1[0] = 100 # left boundary condition
Tnp1[-1] = 0 # right boundary condition
for i in range(1, Nx - 1):
Tnp1[i] = Tn[i] + dt * (Tn[i+1] - 2*Tn[i] + Tn[i-1]) / dx**2
Tn = Tnp1
# Plot the final temperature field
plt.plot(x, Tn)
plt.xlabel('x')
plt.ylabel('T(x)')
plt.show()
ווי אַזוי אַרבעט בילד דור פֿון טעקסט?
זינט עס איז שיין פאָלקס אויף דער אינטערנעץ, מיר קענען אויך קאָנטראָלירן ווי בילד דור אַרבעט.
נאַטירלעך שפּראַך פּראַסעסינג (NLP) מעטהאָדס און נוראַל נעטוואָרקס. און זיי זענען אָפט געניצט צו צושטעלן אַ סטאַביל דיפיוזשאַן מאָדעל פֿאַר טעקסט-צו-בילד קאַנווערזשאַן. א ברייט באַשרייַבונג פון ווי צו ויספירן עס איז צוגעשטעלט אונטן:
1- טאָקעניזע די ווערטער אין טעקסט דאַטן, און עלימינירן האַלטן ווערטער און פּונקטואַציע. קער די ווערטער אין נומעריקאַל וואַלועס. עס איז טייל פון די פּרעפּראָסעססינג (וואָרט עמבעדדינגס).
import nltk
from nltk.tokenize import word_tokenize
nltk.download('punkt')
# Pre-processing the text data
text = "a bird sitting on a flower. "
words = word_tokenize(text)
words = [word.lower() for word in words if word.isalpha()]
2- לערן ווי צו פאַרבינדן די טעקסט און בילדער מיט אַ נעוראַל נעץ וואָס קאַמביינז אַ ענקאָדער און אַ דיקאָודער. די דעקאָדער נעץ נעמט די לייטאַנט קאָד ווי אַרייַנשרייַב. דערנאָך, עס קריייץ די פֿאַרבונדן בילד נאָך די ענקאָדער נעץ קאַנווערץ די טעקסט דאַטן אין אַ סאָליד פאַרטרעטונג (לייטאַנט קאָד).
import tensorflow as tf
# Define the encoder model
encoder = tf.keras.Sequential()
encoder.add(tf.keras.layers.Embedding(input_dim=vocab_size,
output_dim=latent_dim))
encoder.add(tf.keras.layers.GRU(latent_dim))
encoder.add(tf.keras.layers.Dense(latent_dim))
# Define the decoder model
decoder = tf.keras.Sequential()
decoder.add(tf.keras.layers.Dense(latent_dim,
input_shape=(latent_dim,)))
decoder.add(tf.keras.layers.GRU(latent_dim))
decoder.add(tf.keras.layers.Dense(vocab_size))
# Combine the encoder and decoder into an end-to-end model
model = tf.keras.Sequential([encoder, decoder])
3- דורך צושטעלן עס מיט אַ סייזאַבאַל זאַמלונג פון בילדער און טעקסט דיסקריפּשאַנז וואָס זענען מיט זיי. דערנאָך איר קענען באַן די ענקאָדער-דעקאָדער נעץ.
# Compile the model
model.compile(optimizer='adam',
loss='categorical_crossentropy')
# Train the model on the dataset
model.fit(X_train, y_train, epochs=10, batch_size=32)
4- נאָך טריינד די נעץ, איר קען נוצן עס צו פּראָדוצירן בילדער פֿון פריש טעקסט ינפּוץ. און, דאָס איז דורך פידינג די טעקסט אין די ענקאָדער נעץ. דערנאָך איר קענען פּראָדוצירן אַ לייטאַנט קאָד, און דערנאָך קאָרמען די לייטאַנט קאָד אין די דעקאָדער נעץ צו פּראָדוצירן די פֿאַרבונדן בילד.
# Encode the text input
latent_code = encoder.predict(text)
# Generate an image from the latent code
image = decoder.predict(latent_code)
5-די סעלעקציע פון די צונעמען דאַטאַסעט און אָנווער פאַנגקשאַנז איז איינער פון די מערסט קריטיש סטעפּס. די דאַטאַסעט איז וועריד און כּולל אַ ברייט קייט פון בילדער און טעקסט דיסקריפּשאַנז. מיר ווילן צו מאַכן זיכער אַז די בילדער זענען רעאַליסטיש. אויך, מיר דאַרפֿן צו זיין זיכער אַז די טעקסט דיסקריפּשאַנז זענען פיזאַבאַל אַזוי מיר קענען פּלאַן די אָנווער פונקציע.
# Define the loss function
loss = tf.losses.mean_squared_error(y_true, y_pred)
# Compile the model
model.compile(optimizer='adam', loss=loss)
# use diverse dataset
from sklearn.utils import shuffle
X_train, y_train = shuffle(X_train, y_train)
צום סוף, איר קענט עקספּערימענט מיט אנדערע אַרקאַטעקטשערז און מעטאַדאַלאַדזשיז. אַזוי איר קענען פאַרגרעסערן די פאָרשטעלונג פון די מאָדעל, אַזאַ ווי ופמערקזאַמקייַט מעקאַניזאַמז, GANs אָדער VAEs.
לאָזן אַ ענטפֿערן