整合營銷服務商

          電腦端+手機端+微信端=數(shù)據(jù)同步管理

          免費咨詢熱線:

          JavaScript中淺拷貝和深拷貝的區(qū)別和實現(xiàn)

          JavaScript中淺拷貝和深拷貝的區(qū)別和實現(xiàn)

          擊右上方紅色按鈕關注“web秀”,讓你真正秀起來!

          前言

          要理解 JavaScript中淺拷貝和深拷貝的區(qū)別,首先要明白JavaScript的數(shù)據(jù)類型。JavaScript有兩種數(shù)據(jù)類型,基礎數(shù)據(jù)類型和引用數(shù)據(jù)類型。

          1. 基礎數(shù)據(jù)類型: undefined、boolean、number、string、null,保存在棧內存中的簡單數(shù)據(jù)

          2. 引用數(shù)據(jù)類型:Array、對象、Function,保存在堆內存空間中

          概述

          如下圖:

          JavaScript中淺拷貝和深拷貝的區(qū)別和實現(xiàn)

          注釋:

          a1=0;a2='this is str';a3=null, 存放在棧內存中;

          var c=[1,2,3] 與 var d={m:20} ,**變量名與內存地址存儲在棧內存中**,**但是**[1,2,3]與{m:20} 作為**對象存儲在堆內存中**;

          基礎數(shù)據(jù)類型的復制

          var a=20;
          var b=a;
          

          如下圖:

          JavaScript中淺拷貝和深拷貝的區(qū)別和實現(xiàn)

          引用數(shù)據(jù)類型的復制

          var m={
          	a:10,
          	b:20
          };
          var n=m;
          

          JavaScript中淺拷貝和深拷貝的區(qū)別和實現(xiàn)

          m與n指向同一個內存空間,當m或者n改變時,另一個也跟著改變

          m.a='web秀';
          console.log(n.a);
          // 輸出 web秀
          

          怎么樣使引用數(shù)據(jù)類型有各自獨立的內存空間???

          深度拷貝方法

          采用遞歸的方法拷貝對象

          JavaScript中淺拷貝和深拷貝的區(qū)別和實現(xiàn)

          ## 奇技淫巧

          利用**基礎數(shù)據(jù)類型**方式,把對象轉換成字符串,進行復制。具體點說就是,用JSON.stringify與JSON.parse實現(xiàn)深拷貝。原因是JSON.stringify(obj)轉換成字符串,變成基本數(shù)據(jù)類型,基本類型拷貝是直接在棧內存新開空間,直接復制一份名-值,不影響之前的對象。請看代碼:

          JavaScript中淺拷貝和深拷貝的區(qū)別和實現(xiàn)

          總結

          1. 淺拷貝(shallow copy):只復制指向某個對象的指針,而不復制對象本身,新舊對象共享一塊內存;

          2. 深拷貝(deep copy):復制并創(chuàng)建一個一摸一樣的對象,不共享內存,修改新對象,舊對象保持不變;

          實現(xiàn)深拷貝主要有2種方法

          (1)遞歸

          (2)JSON.stringify結合JSON.parse

          公告

          喜歡小編的點擊關注哦,了解更多知識!

          者:Zied Haj-Yahia

          翻譯:張玲

          校對:丁楠雅

          本文約2500字,建議閱讀15分鐘。

          本文為你簡要介紹深度學習的基本構成、模型優(yōu)化的幾種方式和模型訓練的一些最佳實踐。

          一年多來,我在LinkedIn、Medium和Arxiv上閱讀了不少深度學習相關文章和研究論文。當我?guī)字苤伴_始麻省理工學院6.S191深度學習在線課程(這里是課程網(wǎng)站的鏈接)以后,我決定寫下這一系列的文章來加深我對深度學習的結構化理解。

          我將發(fā)布以下4個課程:

          • 深度學習簡介
          • 基于神經(jīng)網(wǎng)絡的序列建模
          • 計算機視覺中的深度學習-卷積神經(jīng)網(wǎng)絡
          • 深度生成模型


          對于每門課程,我將概述主要概念,并根據(jù)以前的閱讀資料以及我在統(tǒng)計學和機器學習方面的背景增加更多的細節(jié)和解釋。

          從第2課程開始,我還將為每一課的開源數(shù)據(jù)集添加一個應用程序。

          好的,讓我們開始吧!

          深度學習簡介


          背景

          傳統(tǒng)的機器學習模型在處理結構化數(shù)據(jù)方面一直非常強大,并且已經(jīng)被企業(yè)廣泛用于信用評分、客戶流失預測、消費者定位等。

          這些模型的成功很大程度上取決于特征工程階段的性能:我們越接近業(yè)務,從結構化數(shù)據(jù)中提取相關知識越多,模型就越強大。

          當涉及到非結構化數(shù)據(jù)(圖像、文本、語音、視頻)時,手動特征工程是耗時的、脆弱的,而且在實踐中是不可擴展的,這就是神經(jīng)網(wǎng)絡因其可以從原始數(shù)據(jù)中自動發(fā)現(xiàn)特征或者分類所需要的表示而越來越受歡迎的原因。它取代手動特征工程,允許一臺機器既能學習特征又能利用這些特征執(zhí)行特定的任務。

          硬件(GPU)和軟件(與AI相關的高級模型/研究)的進步也提升了神經(jīng)網(wǎng)絡的學習效果。

          基本架構

          深度學習的基本組成部分是感知器,它是神經(jīng)網(wǎng)絡中的單個神經(jīng)元。

          給定一組有限的m個輸入(例如,m個單詞或m個像素),我們將每個輸入乘以一個權重

          ,然后對輸入的加權組合進行求和,并添加一個偏差,最后將它們輸入非線性激活函數(shù),輸出




          • 偏差會向輸入空間添加另一個維度。因此,在輸入全零向量的情況下,激活函數(shù)依然提供輸出。它在某種程度上是輸出的一部分,與輸入無關。
          • 激活函數(shù)的目的是將非線性引入網(wǎng)絡。實際上,無論輸入分布如何,線性激活函數(shù)都會產生線性決策。非線性使我們能夠更好地逼近任意復雜的函數(shù),這里有一些常見的激活函數(shù)示例:





          深度神經(jīng)網(wǎng)絡只是組合多個感知器(隱藏層),以產生輸出。




          現(xiàn)在,我們已經(jīng)了解了深度神經(jīng)網(wǎng)絡的基本架構,讓我們看看它如何用于給定的任務。

          訓練神經(jīng)網(wǎng)絡

          比方說,對于一組X射線圖像,我們需要模型來自動區(qū)分病人與正常人。

          為此,機器學習模型需要像人一樣通過觀察病人和正常人的圖像來學會區(qū)分這兩類圖像。因此,它們自動理解可以更好地描述每類圖像的模式,這就是我們所說的訓練階段。

          具體地說,模式是一些輸入(圖像、部分圖像或其他模式)的加權組合。因此,訓練階段只不過是我們估計模型權重(也稱為參數(shù))的階段。

          當談論估計時,談論的是我們必須優(yōu)化的目標函數(shù)。構建這個函數(shù),應該最好地反映訓練階段的性能。當涉及到預測任務時,這個目標函數(shù)通常稱為損失函數(shù),度量不正確的預測所產生的成本。當模型預測非常接近真實輸出的東西時,損失函數(shù)非常低,反之亦然。

          在存在輸入數(shù)據(jù)的情況下,我們計算經(jīng)驗損失(分類的二元交叉熵損失和回歸的均方差損失)來度量整個數(shù)據(jù)集上的總損失。




          由于損失是網(wǎng)絡權重的函數(shù),我們的任務是找到實現(xiàn)最低損失的權重集:



          如果只有兩個權重

          ,我們可以繪制下面的損失函數(shù)圖。我們想要做的是找出這種損失的最小值,從而找出損失達到最小值時的權重值。




          為了最小化損失函數(shù),我們可以應用梯度下降算法:

          • 首先,我們隨機選擇權重的初始p向量(例如,遵循正態(tài)分布)。
          • 然后,我們計算初始p向量中損失函數(shù)的梯度。
          • 梯度方向指示的是使損失函數(shù)最大化的方向。 因此,我們在梯度的反方向上邁出了一小步,使用此更新規(guī)則相應地更新權重值:



          • 我們不斷移動,直至收斂達到這張圖的最低點(局部最小值)。


          注意:

          • 在更新規(guī)則中,
          • 學習率,決定著我們在梯度反方向上移動步伐的大小。它的選擇非常重要,因為現(xiàn)代神經(jīng)網(wǎng)絡的架構是非常非凸的。如果學習率太低,模型可能陷入局部最小值;如果學習率太大,模型則可能發(fā)散。可以采用自適應學習率來調整梯度每次迭代時的學習率。有關更詳細的說明,請閱讀Sebastian Ruder對梯度下降優(yōu)化算法的概述。
          • 為了計算給定向量的損失函數(shù)的梯度,我們使用反向傳播。考慮上面的簡單神經(jīng)網(wǎng)路絡,它包含一個隱含層和一個輸出層。想要計算與每個參數(shù)有關的損失函數(shù)的梯度
          • ,首先,應用鏈規(guī)則,因為
          • 。然后,再次應用鏈規(guī)則來將梯度反向傳播給前一層。出于同樣的原因,我們可以這樣做,因為
          • (隱藏狀態(tài))僅取決于輸入
          • 。因此,反向傳播包括使用來自后面層的梯度對網(wǎng)絡中每個權重重復這樣的過程。




          神經(jīng)網(wǎng)絡實踐


          • 在存在大數(shù)據(jù)集的情況下,關于每個權重的梯度計算可能非常昂貴(考慮反向傳播中的鏈規(guī)則)。為此,我們可以計算數(shù)據(jù)子集(小批量)的梯度,將其作為真實梯度的估計值。它能給出比僅隨機進行一次觀察的隨機梯度下降(SGD)更準確的梯度估計值,而且比使用全部數(shù)據(jù)進行梯度計算的方式要快。每次迭代使用小批量梯度計算,可以快速訓練模型,特別是當我們使用不同的線程(GPU)時。我們可以并行計算每個迭代:每個權重和梯度的批處理在單獨的線程中計算。然后,收集計算以完成迭代。
          • 和任何其他“經(jīng)典”機器學習算法一樣,神經(jīng)網(wǎng)絡可能面臨過度擬合的問題。理想情況下,在機器學習中,我們希望構建這樣的模型:能夠從訓練數(shù)據(jù)中學習問題描述,而且也能夠很好地概括看不見的測試數(shù)據(jù)。正則化是一種限制優(yōu)化問題、避免產生復雜模型(即避免記憶數(shù)據(jù))的方法。當談論正則化時,我們通常會討論Dropout。它在訓練階段隨機丟棄(丟棄,即將相關激活設置為0)某些隱藏神經(jīng)元或者在有可能過度擬合的情況下提前結束訓練過程。為此,我們計算相對于訓練迭代次數(shù)的訓練和測試階段的損失。當測試階段的損失函數(shù)開始增加時,我們停止學習。


          總結


          第一篇文章是對深度學習的介紹,可歸納為3個要點:

          • 首先,我們了解了深度學習的基本組成部分,即感知器。
          • 然后,我們學會了將這些感知器組合在一起以組成更復雜的層次模型,并學會了如何使用反向傳播和梯度下降從數(shù)學上來優(yōu)化這些模型。
          • 最后,我們已經(jīng)看到了在現(xiàn)實生活中訓練這些模型的一些實際挑戰(zhàn),以及一些最佳實踐,如自適應學習,批處理和避免過度擬合的正則化。


          下一篇文章將是關于神經(jīng)網(wǎng)絡的序列建模。我們將學習如何模擬序列,重點關注遞歸神經(jīng)網(wǎng)絡(RNN)及其短期記憶和長期短期記憶(LSTM)以及它們在多個時間步長內跟蹤信息的能力。

          敬請關注!

          原文標題:Introduction to Deep Learning原文鏈接:https://www.kdnuggets.com/2018/09/introduction-deep-learning.html


          譯者簡介


          張玲,在崗數(shù)據(jù)分析師,計算機碩士畢業(yè)。從事數(shù)據(jù)工作,需要重塑自我的勇氣,也需要終生學習的毅力。但我依舊熱愛它的嚴謹,癡迷它的藝術。數(shù)據(jù)海洋一望無境,數(shù)據(jù)工作充滿挑戰(zhàn)。感謝數(shù)據(jù)派THU提供如此專業(yè)的平臺,希望在這里能和最專業(yè)的你們共同進步!

          — 完 —

          關注清華-青島數(shù)據(jù)科學研究院官方微信公眾平臺“THU數(shù)據(jù)派”及姊妹號“數(shù)據(jù)派THU”獲取更多講座福利及優(yōu)質內容。

          深度學習自動生成HTML代碼

          選自Floydhub

          作者:Emil Wallner

          機器之心編譯

          如何用前端頁面原型生成對應的代碼一直是我們關注的問題,本文作者根據(jù) pix2code 等論文構建了一個強大的前端代碼生成模型,并詳細解釋了如何利用 LSTM 與 CNN 將設計原型編寫為 HTML 和 CSS 網(wǎng)站。

          項目鏈接:github.com/emilwallner…

          在未來三年內,深度學習將改變前端開發(fā)。它將會加快原型設計速度,拉低開發(fā)軟件的門檻。

          Tony Beltramelli 在去年發(fā)布了論文《pix2code: Generating Code from a Graphical User Interface Screenshot》,Airbnb 也發(fā)布Sketch2code(airbnb.design/sketching-i…)。

          目前,自動化前端開發(fā)的最大阻礙是計算能力。但我們已經(jīng)可以使用目前的深度學習算法,以及合成訓練數(shù)據(jù)來探索人工智能自動構建前端的方法。在本文中,作者將教神經(jīng)網(wǎng)絡學習基于一張圖片和一個設計模板來編寫一個 HTML 和 CSS 網(wǎng)站。以下是該過程的簡要概述:

          1)向訓練過的神經(jīng)網(wǎng)絡輸入一個設計圖

          2)神經(jīng)網(wǎng)絡將圖片轉化為 HTML 標記語言

          3)渲染輸出

          我們將分三步從易到難構建三個不同的模型,首先,我們構建最簡單地版本來掌握移動部件。第二個版本 HTML 專注于自動化所有步驟,并簡要解釋神經(jīng)網(wǎng)絡層。在最后一個版本 Bootstrap 中,我們將創(chuàng)建一個模型來思考和探索 LSTM 層。

          代碼地址:

          • github.com/emilwallner…
          • www.floydhub.com/emilwallner…

          所有 FloydHub notebook 都在 floydhub 目錄中,本地 notebook 在 local 目錄中。

          本文中的模型構建基于 Beltramelli 的論文《pix2code: Generating Code from a Graphical User Interface Screenshot》和 Jason Brownlee 的圖像描述生成教程,并使用 Python 和 Keras 完成。

          核心邏輯

          我們的目標是構建一個神經(jīng)網(wǎng)絡,能夠生成與截圖對應的 HTML/CSS 標記語言。

          訓練神經(jīng)網(wǎng)絡時,你先提供幾個截圖和對應的 HTML 代碼。網(wǎng)絡通過逐個預測所有匹配的 HTML 標記語言來學習。預測下一個標記語言的標簽時,網(wǎng)絡接收到截圖和之前所有正確的標記。

          這里是一個簡單的訓練數(shù)據(jù)示例:docs.google.com/spreadsheet…。

          創(chuàng)建逐詞預測的模型是現(xiàn)在最常用的方法,也是本教程使用的方法。

          注意:每次預測時,神經(jīng)網(wǎng)絡接收的是同樣的截圖。也就是說如果網(wǎng)絡需要預測 20 個單詞,它就會得到 20 次同樣的設計截圖。現(xiàn)在,不用管神經(jīng)網(wǎng)絡的工作原理,只需要專注于神經(jīng)網(wǎng)絡的輸入和輸出。

          我們先來看前面的標記(markup)。假如我們訓練神經(jīng)網(wǎng)絡的目的是預測句子「I can code」。當網(wǎng)絡接收「I」時,預測「can」。下一次時,網(wǎng)絡接收「I can」,預測「code」。它接收所有之前單詞,但只預測下一個單詞。

          神經(jīng)網(wǎng)絡根據(jù)數(shù)據(jù)創(chuàng)建特征。神經(jīng)網(wǎng)絡構建特征以連接輸入數(shù)據(jù)和輸出數(shù)據(jù)。它必須創(chuàng)建表征來理解每個截圖的內容和它所需要預測的 HTML 語法,這些都是為預測下一個標記構建知識。把訓練好的模型應用到真實世界中和模型訓練過程差不多。

          我們無需輸入正確的 HTML 標記,網(wǎng)絡會接收它目前生成的標記,然后預測下一個標記。預測從「起始標簽」(start tag)開始,到「結束標簽」(end tag)終止,或者達到最大限制時終止。

          Hello World 版

          現(xiàn)在讓我們構建 Hello World 版實現(xiàn)。我們將饋送一張帶有「Hello World!」字樣的截屏到神經(jīng)網(wǎng)絡中,并訓練它生成對應的標記語言。

          首先,神經(jīng)網(wǎng)絡將原型設計轉換為一組像素值。且每一個像素點有 RGB 三個通道,每個通道的值都在 0-255 之間。

          為了以神經(jīng)網(wǎng)絡能理解的方式表征這些標記,我使用了 one-hot 編碼。因此句子「I can code」可以映射為以下形式。

          在上圖中,我們的編碼包含了開始和結束的標簽。這些標簽能為神經(jīng)網(wǎng)絡提供開始預測和結束預測的位置信息。以下是這些標簽的各種組合以及對應 one-hot 編碼的情況。

          我們會使每個單詞在每一輪訓練中改變位置,因此這允許模型學習序列而不是記憶詞的位置。在下圖中有四個預測,每一行是一個預測。且左邊代表 RGB 三色通道和之前的詞,右邊代表預測結果和紅色的結束標簽。

          #Length of longest sentence
           max_caption_len=3
          #Size of vocabulary 
           vocab_size=3
          # Load one screenshot for each word and turn them into digits 
           images=[]
          for i in range(2):
           images.append(img_to_array(load_img('screenshot.jpg', target_size=(224, 224))))
           images=np.array(images, dtype=float)
          # Preprocess input for the VGG16 model
           images=preprocess_input(images)
          #Turn start tokens into one-hot encoding
           html_input=np.array(
           [[[0., 0., 0.], #start
           [0., 0., 0.],
           [1., 0., 0.]],
           [[0., 0., 0.], #start <HTML>Hello World!</HTML>
           [1., 0., 0.],
           [0., 1., 0.]]])
          #Turn next word into one-hot encoding
           next_words=np.array(
           [[0., 1., 0.], # <HTML>Hello World!</HTML>
           [0., 0., 1.]]) # end
          # Load the VGG16 model trained on imagenet and output the classification feature
           VGG=VGG16(weights='imagenet', include_top=True)
          # Extract the features from the image
           features=VGG.predict(images)
          #Load the feature to the network, apply a dense layer, and repeat the vector
           vgg_feature=Input(shape=(1000,))
           vgg_feature_dense=Dense(5)(vgg_feature)
           vgg_feature_repeat=RepeatVector(max_caption_len)(vgg_feature_dense)
          # Extract information from the input seqence 
           language_input=Input(shape=(vocab_size, vocab_size))
           language_model=LSTM(5, return_sequences=True)(language_input)
          # Concatenate the information from the image and the input
           decoder=concatenate([vgg_feature_repeat, language_model])
          # Extract information from the concatenated output
           decoder=LSTM(5, return_sequences=False)(decoder)
          # Predict which word comes next
           decoder_output=Dense(vocab_size, activation='softmax')(decoder)
          # Compile and run the neural network
           model=Model(inputs=[vgg_feature, language_input], outputs=decoder_output)
           model.compile(loss='categorical_crossentropy', optimizer='rmsprop')
          # Train the neural network
           model.fit([features, html_input], next_words, batch_size=2, shuffle=False, epochs=1000)
          復制代碼
          

          在 Hello World 版本中,我們使用三個符號「start」、「Hello World」和「end」。字符級的模型要求更小的詞匯表和受限的神經(jīng)網(wǎng)絡,而單詞級的符號在這里可能有更好的性能。

          以下是執(zhí)行預測的代碼:

          # Create an empty sentence and insert the start token
           sentence=np.zeros((1, 3, 3)) # [[0,0,0], [0,0,0], [0,0,0]]
           start_token=[1., 0., 0.] # start
           sentence[0][2]=start_token # place start in empty sentence
          # Making the first prediction with the start token
           second_word=model.predict([np.array([features[1]]), sentence])
          # Put the second word in the sentence and make the final prediction
           sentence[0][1]=start_token
           sentence[0][2]=np.round(second_word)
           third_word=model.predict([np.array([features[1]]), sentence])
          # Place the start token and our two predictions in the sentence 
           sentence[0][0]=start_token
           sentence[0][1]=np.round(second_word)
           sentence[0][2]=np.round(third_word)
          # Transform our one-hot predictions into the final tokens
           vocabulary=["start", "<HTML><center><H1>Hello World!</H1></center></HTML>", "end"]
          for i in sentence[0]:
          print(vocabulary[np.argmax(i)], end=' ')
          復制代碼
          

          輸出

          • 10 epochs: start start start
          • 100 epochs: start <HTML><center><H1>Hello World!</H1></center></HTML> <HTML><center><H1>Hello World!</H1></center></HTML>
          • 300 epochs: start <HTML><center><H1>Hello World!</H1></center></HTML> end

          我走過的坑:

          • 在收集數(shù)據(jù)之前構建第一個版本。在本項目的早期階段,我設法獲得 Geocities 托管網(wǎng)站的舊版存檔,它有 3800 萬的網(wǎng)站。但我忽略了減少 100K 大小詞匯所需要的巨大工作量。
          • 訓練一個 TB 級的數(shù)據(jù)需要優(yōu)秀的硬件或極其有耐心。在我的 Mac 遇到幾個問題后,最終用上了強大的遠程服務器。我預計租用 8 個現(xiàn)代 CPU 和 1 GPS 內部鏈接以運行我的工作流。
          • 在理解輸入與輸出數(shù)據(jù)之前,其它部分都似懂非懂。輸入 X 是屏幕的截圖和以前標記的標簽,輸出 Y 是下一個標記的標簽。當我理解這一點時,其它問題都更加容易弄清了。此外,嘗試其它不同的架構也將更加容易。
          • 圖片到代碼的網(wǎng)絡其實就是自動描述圖像的模型。即使我意識到了這一點,但仍然錯過了很多自動圖像摘要方面的論文,因為它們看起來不夠炫酷。一旦我意識到了這一點,我對問題空間的理解就變得更加深刻了。

          在 FloydHub 上運行代碼

          FloydHub 是一個深度學習訓練平臺,我自從開始學習深度學習時就對它有所了解,我也常用它訓練和管理深度學習試驗。我們能安裝它并在 10 分鐘內運行第一個模型,它是在云 GPU 上訓練模型最好的選擇。若果讀者沒用過 FloydHub,可以花 10 分鐘左右安裝并了解。

          FloydHub 地址:www.floydhub.com/

          復制 Repo:

          https://github.com/emilwallner/Screenshot-to-code-in-Keras.git
          復制代碼
          

          登錄并初始化 FloydHub 命令行工具:

          cd Screenshot-to-code-in-Keras
          floyd login
          floyd init s2c
          復制代碼
          

          在 FloydHub 云 GPU 機器上運行 Jupyter notebook:

          floyd run --gpu --env tensorflow-1.4 --data emilwallner/datasets/imagetocode/2:data --mode jupyter
          復制代碼
          

          所有的 notebook 都放在 floydbub 目錄下。一旦我們開始運行模型,那么在 floydhub/Helloworld/helloworld.ipynb 下可以找到第一個 Notebook。更多詳情請查看本項目早期的 flags。

          HTML 版本

          在這個版本中,我們將關注與創(chuàng)建一個可擴展的神經(jīng)網(wǎng)絡模型。該版本并不能直接從隨機網(wǎng)頁預測 HTML,但它是探索動態(tài)問題不可缺少的步驟。

          概覽

          如果我們將前面的架構擴展為以下右圖展示的結構,那么它就能更高效地處理識別與轉換過程。

          該架構主要有兩個部,即編碼器與解碼器。編碼器是我們創(chuàng)建圖像特征和前面標記特征(markup features)的部分。特征是網(wǎng)絡創(chuàng)建原型設計和標記語言之間聯(lián)系的構建塊。在編碼器的末尾,我們將圖像特征傳遞給前面標記的每一個單詞。隨后解碼器將結合原型設計特征和標記特征以創(chuàng)建下一個標簽的特征,這一個特征可以通過全連接層預測下一個標簽。

          設計原型的特征

          因為我們需要為每個單詞插入一個截屏,這將會成為訓練神經(jīng)網(wǎng)絡的瓶頸。因此我們抽取生成標記語言所需要的信息來替代直接使用圖像。這些抽取的信息將通過預訓練的 CNN 編碼到圖像特征中,且我們將使用分類層之前的層級輸出以抽取特征。

          我們最終得到 1536 個 8*8 的特征圖,雖然我們很難直觀地理解它,但神經(jīng)網(wǎng)絡能夠從這些特征中抽取元素的對象和位置。

          標記特征

          在 Hello World 版本中,我們使用 one-hot 編碼以表征標記。而在該版本中,我們將使用詞嵌入表征輸入并使用 one-hot 編碼表示輸出。我們構建每個句子的方式保持不變,但我們映射每個符號的方式將會變化。one-hot 編碼將每一個詞視為獨立的單元,而詞嵌入會將輸入數(shù)據(jù)表征為一個實數(shù)列表,這些實數(shù)表示標記標簽之間的關系。

          上面詞嵌入的維度為 8,但一般詞嵌入的維度會根據(jù)詞匯表的大小在 50 到 500 間變動。以上每個單詞的八個數(shù)值就類似于神經(jīng)網(wǎng)絡中的權重,它們傾向于刻畫單詞之間的聯(lián)系(Mikolov alt el., 2013)。這就是我們開始部署標記特征(markup features)的方式,而這些神經(jīng)網(wǎng)絡訓練的特征會將輸入數(shù)據(jù)和輸出數(shù)據(jù)聯(lián)系起來。

          編碼器

          我們現(xiàn)在將詞嵌入饋送到 LSTM 中,并期望能返回一系列的標記特征。這些標記特征隨后會饋送到一個 Time Distributed 密集層,該層級可以視為有多個輸入和輸出的全連接層。

          和嵌入與 LSTM 層相平行的還有另外一個處理過程,其中圖像特征首先會展開成一個向量,然后再饋送到一個全連接層而抽取出高級特征。這些圖像特征隨后會與標記特征相級聯(lián)而作為編碼器的輸出。

          標記特征

          如下圖所示,現(xiàn)在我們將詞嵌入投入到 LSTM 層中,所有的語句都會用零填充以獲得相同的向量長度。

          為了混合信號并尋找高級模式,我們運用了一個 TimeDistributed 密集層以抽取標記特征。TimeDistributed 密集層和一般的全連接層非常相似,且它有多個輸入與輸出。

          圖像特征

          對于另一個平行的過程,我們需要將圖像的所有像素值展開成一個向量,因此信息不會被改變,它們只會用來識別。

          如上,我們會通過全連接層混合信號并抽取更高級的概念。因為我們并不只是處理一個輸入值,因此使用一般的全連接層就行了。

          級聯(lián)圖像特征和標記特征

          所有的語句都被填充以創(chuàng)建三個標記特征。因為我們已經(jīng)預處理了圖像特征,所以我們能為每一個標記特征添加圖像特征。

          如上,在復制圖像特征到對應的標記特征后,我們得到了新的圖像-標記特征(image-markup features),這就是我們饋送到解碼器的輸入值。

          解碼器

          現(xiàn)在,我們使用圖像-標記特征來預測下一個標簽。

          在下面的案例中,我們使用三個圖像-標簽特征對來輸出下一個標簽特征。注意 LSTM 層不應該返回一個長度等于輸入序列的向量,而只需要預測預測一個特征。在我們的案例中,這個特征將預測下一個標簽,它包含了最后預測的信息。

          最后的預測

          密集層會像傳統(tǒng)前饋網(wǎng)絡那樣工作,它將下一個標簽特征中的 512 個值與最后的四個預測連接起來,即我們在詞匯表所擁有的四個單詞:start、hello、world 和 end。密集層最后采用的 softmax 函數(shù)會為四個類別產生一個概率分布,例如 [0.1, 0.1, 0.1, 0.7] 將預測第四個詞為下一個標簽。

          # Load the images and preprocess them for inception-resnet
           images=[]
           all_filenames=listdir('images/')
           all_filenames.sort()
          for filename in all_filenames:
           images.append(img_to_array(load_img('images/'+filename, target_size=(299, 299))))
           images=np.array(images, dtype=float)
           images=preprocess_input(images)
          # Run the images through inception-resnet and extract the features without the classification layer
           IR2=InceptionResNetV2(weights='imagenet', include_top=False)
           features=IR2.predict(images)
          # We will cap each input sequence to 100 tokens
           max_caption_len=100
          # Initialize the function that will create our vocabulary 
           tokenizer=Tokenizer(filters='', split=" ", lower=False)
          # Read a document and return a string
          def load_doc(filename):
           file=open(filename, 'r')
           text=file.read()
           file.close()
          return text
          # Load all the HTML files
           X=[]
           all_filenames=listdir('html/')
           all_filenames.sort()
          for filename in all_filenames:
           X.append(load_doc('html/'+filename))
          # Create the vocabulary from the html files
           tokenizer.fit_on_texts(X)
          # Add +1 to leave space for empty words
           vocab_size=len(tokenizer.word_index) + 1
          # Translate each word in text file to the matching vocabulary index
           sequences=tokenizer.texts_to_sequences(X)
          # The longest HTML file
           max_length=max(len(s) for s in sequences)
          # Intialize our final input to the model
           X, y, image_data=list(), list(), list()
          for img_no, seq in enumerate(sequences):
          for i in range(1, len(seq)):
          # Add the entire sequence to the input and only keep the next word for the output
           in_seq, out_seq=seq[:i], seq[i]
          # If the sentence is shorter than max_length, fill it up with empty words
           in_seq=pad_sequences([in_seq], maxlen=max_length)[0]
          # Map the output to one-hot encoding
           out_seq=to_categorical([out_seq], num_classes=vocab_size)[0]
          # Add and image corresponding to the HTML file
           image_data.append(features[img_no])
          # Cut the input sentence to 100 tokens, and add it to the input data
           X.append(in_seq[-100:])
           y.append(out_seq)
           X, y, image_data=np.array(X), np.array(y), np.array(image_data)
          # Create the encoder
           image_features=Input(shape=(8, 8, 1536,))
           image_flat=Flatten()(image_features)
           image_flat=Dense(128, activation='relu')(image_flat)
           ir2_out=RepeatVector(max_caption_len)(image_flat)
           language_input=Input(shape=(max_caption_len,))
           language_model=Embedding(vocab_size, 200, input_length=max_caption_len)(language_input)
           language_model=LSTM(256, return_sequences=True)(language_model)
           language_model=LSTM(256, return_sequences=True)(language_model)
           language_model=TimeDistributed(Dense(128, activation='relu'))(language_model)
          # Create the decoder
           decoder=concatenate([ir2_out, language_model])
           decoder=LSTM(512, return_sequences=False)(decoder)
           decoder_output=Dense(vocab_size, activation='softmax')(decoder)
          # Compile the model
           model=Model(inputs=[image_features, language_input], outputs=decoder_output)
           model.compile(loss='categorical_crossentropy', optimizer='rmsprop')
          # Train the neural network
           model.fit([image_data, X], y, batch_size=64, shuffle=False, epochs=2)
          # map an integer to a word
          def word_for_id(integer, tokenizer):
          for word, index in tokenizer.word_index.items():
          if index==integer:
          return word
          return None
          # generate a description for an image
          def generate_desc(model, tokenizer, photo, max_length):
          # seed the generation process
           in_text='START'
          # iterate over the whole length of the sequence
          for i in range(900):
          # integer encode input sequence
           sequence=tokenizer.texts_to_sequences([in_text])[0][-100:]
          # pad input
           sequence=pad_sequences([sequence], maxlen=max_length)
          # predict next word
           yhat=model.predict([photo,sequence], verbose=0)
          # convert probability to integer
           yhat=np.argmax(yhat)
          # map integer to word
           word=word_for_id(yhat, tokenizer)
          # stop if we cannot map the word
          if word is None:
          break
          # append as input for generating the next word
           in_text +=' ' + word
          # Print the prediction
          print(' ' + word, end='')
          # stop if we predict the end of the sequence
          if word=='END':
          break
          return
          # Load and image, preprocess it for IR2, extract features and generate the HTML
           test_image=img_to_array(load_img('images/87.jpg', target_size=(299, 299)))
           test_image=np.array(test_image, dtype=float)
           test_image=preprocess_input(test_image)
           test_features=IR2.predict(np.array([test_image]))
           generate_desc(model, tokenizer, np.array(test_features), 100)
          復制代碼
          

          輸出

          訓練不同輪數(shù)所生成網(wǎng)站的地址:

          • 250 epochs:emilwallner.github.io/html/250_ep…
          • 350 epochs:emilwallner.github.io/html/350_ep…
          • 450 epochs:emilwallner.github.io/html/450_ep…
          • 550 epochs:emilwallner.github.io/html/550_ep…

          我走過的坑:

          • 我認為理解 LSTM 比 CNN 要難一些。當我展開 LSTM 后,它們會變得容易理解一些。此外,我們在嘗試理解 LSTM 前,可以先關注輸入與輸出特征。
          • 從頭構建一個詞匯表要比壓縮一個巨大的詞匯表容易得多。這樣的構建包括字體、div 標簽大小、變量名的 hex 顏色和一般單詞。
          • 大多數(shù)庫是為解析文本文檔而構建。在庫的使用文檔中,它們會告訴我們如何通過空格進行分割,而不是代碼,我們需要自定義解析的方式。
          • 我們可以從 ImageNet 上預訓練的模型抽取特征。然而,相對于從頭訓練的 pix2code 模型,損失要高 30% 左右。此外,我對于使用基于網(wǎng)頁截屏預訓練的 inception-resnet 網(wǎng)絡很有興趣。

          Bootstrap 版本

          在最終版本中,我們使用 pix2code 論文中生成 bootstrap 網(wǎng)站的數(shù)據(jù)集。使用 Twitter 的 Bootstrap 庫(getbootstrap.com/),我們可以結合 HTML 和 CSS,降低詞匯表規(guī)模。

          我們將使用這一版本為之前未見過的截圖生成標記。我們還深入研究它如何構建截圖和標記的先驗知識。

          我們不在 bootstrap 標記上訓練,而是使用 17 個簡化 token,將其編譯成 HTML 和 CSS。數(shù)據(jù)集(github.com/tonybeltram…)包括 1500 個測試截圖和 250 個驗證截圖。平均每個截圖有 65 個 token,一共有 96925 個訓練樣本。

          我們稍微修改一下 pix2code 論文中的模型,使之預測網(wǎng)絡組件的準確率達到 97%。

          端到端方法

          從預訓練模型中提取特征在圖像描述生成模型中效果很好。但是幾次實驗后,我發(fā)現(xiàn) pix2code 的端到端方法效果更好。在我們的模型中,我們用輕量級卷積神經(jīng)網(wǎng)絡替換預訓練圖像特征。我們不使用最大池化來增加信息密度,而是增加步幅。這可以保持前端元素的位置和顏色。

          存在兩個核心模型:卷積神經(jīng)網(wǎng)絡(CNN)和循環(huán)神經(jīng)網(wǎng)絡(RNN)。最常用的循環(huán)神經(jīng)網(wǎng)絡是長短期記憶(LSTM)網(wǎng)絡。我之前的文章中介紹過 CNN 教程,本文主要介紹 LSTM。

          理解 LSTM 中的時間步

          關于 LSTM 比較難理解的是時間步。我們的原始神經(jīng)網(wǎng)絡有兩個時間步,如果你給它「Hello」,它就會預測「World」。但是它會試圖預測更多時間步。下例中,輸入有四個時間步,每個單詞對應一個時間步。

          LSTM 適合時序數(shù)據(jù)的輸入,它是一種適合順序信息的神經(jīng)網(wǎng)絡。模型展開圖示如下,對于每個循環(huán)步,你需要保持同樣的權重。

          加權后的輸入與輸出特征在級聯(lián)后輸入到激活函數(shù),并作為當前時間步的輸出。因為我們重復利用了相同的權重,它們將從一些輸入獲取信息并構建序列的知識。下面是 LSTM 在每一個時間步上的簡化版處理過程:

          理解 LSTM 層級中的單元

          每一層 LSTM 單元的總數(shù)決定了它記憶的能力,同樣也對應于每一個輸出特征的維度大小。LSTM 層級中的每一個單元將學習如何追蹤句法的不同方面。以下是一個 LSTM 單元追蹤標簽行信息的可視化,它是我們用來訓練 bootstrap 模型的簡單標記語言。

          每一個 LSTM 單元會維持一個單元狀態(tài),我們可以將單元狀態(tài)視為記憶。權重和激活值可使用不同的方式修正狀態(tài)值,這令 LSTM 層可以通過保留或遺忘輸入信息而得到精調。除了處理當前輸入信息與輸出信息,LSTM 單元還需要修正記憶狀態(tài)以傳遞到下一個時間步。

          dir_name='resources/eval_light/'
          # Read a file and return a string
          def load_doc(filename):
           file=open(filename, 'r')
           text=file.read()
           file.close()
          return text
          def load_data(data_dir):
           text=[]
           images=[]
          # Load all the files and order them
           all_filenames=listdir(data_dir)
           all_filenames.sort()
          for filename in (all_filenames):
          if filename[-3:]=="npz":
          # Load the images already prepared in arrays
           image=np.load(data_dir+filename)
           images.append(image['features'])
          else:
          # Load the boostrap tokens and rap them in a start and end tag
           syntax='<START> ' + load_doc(data_dir+filename) + ' <END>'
          # Seperate all the words with a single space
           syntax=' '.join(syntax.split())
          # Add a space after each comma
           syntax=syntax.replace(',', ' ,')
           text.append(syntax)
           images=np.array(images, dtype=float)
          return images, text
           train_features, texts=load_data(dir_name)
          # Initialize the function to create the vocabulary 
           tokenizer=Tokenizer(filters='', split=" ", lower=False)
          # Create the vocabulary 
           tokenizer.fit_on_texts([load_doc('bootstrap.vocab')])
          # Add one spot for the empty word in the vocabulary 
           vocab_size=len(tokenizer.word_index) + 1
          # Map the input sentences into the vocabulary indexes
           train_sequences=tokenizer.texts_to_sequences(texts)
          # The longest set of boostrap tokens
           max_sequence=max(len(s) for s in train_sequences)
          # Specify how many tokens to have in each input sentence
           max_length=48
          def preprocess_data(sequences, features):
           X, y, image_data=list(), list(), list()
          for img_no, seq in enumerate(sequences):
          for i in range(1, len(seq)):
          # Add the sentence until the current count(i) and add the current count to the output
           in_seq, out_seq=seq[:i], seq[i]
          # Pad all the input token sentences to max_sequence
           in_seq=pad_sequences([in_seq], maxlen=max_sequence)[0]
          # Turn the output into one-hot encoding
           out_seq=to_categorical([out_seq], num_classes=vocab_size)[0]
          # Add the corresponding image to the boostrap token file
           image_data.append(features[img_no])
          # Cap the input sentence to 48 tokens and add it
           X.append(in_seq[-48:])
           y.append(out_seq)
          return np.array(X), np.array(y), np.array(image_data)
           X, y, image_data=preprocess_data(train_sequences, train_features)
          #Create the encoder
           image_model=Sequential()
           image_model.add(Conv2D(16, (3, 3), padding='valid', activation='relu', input_shape=(256, 256, 3,)))
           image_model.add(Conv2D(16, (3,3), activation='relu', padding='same', strides=2))
           image_model.add(Conv2D(32, (3,3), activation='relu', padding='same'))
           image_model.add(Conv2D(32, (3,3), activation='relu', padding='same', strides=2))
           image_model.add(Conv2D(64, (3,3), activation='relu', padding='same'))
           image_model.add(Conv2D(64, (3,3), activation='relu', padding='same', strides=2))
           image_model.add(Conv2D(128, (3,3), activation='relu', padding='same'))
           image_model.add(Flatten())
           image_model.add(Dense(1024, activation='relu'))
           image_model.add(Dropout(0.3))
           image_model.add(Dense(1024, activation='relu'))
           image_model.add(Dropout(0.3))
           image_model.add(RepeatVector(max_length))
           visual_input=Input(shape=(256, 256, 3,))
           encoded_image=image_model(visual_input)
           language_input=Input(shape=(max_length,))
           language_model=Embedding(vocab_size, 50, input_length=max_length, mask_zero=True)(language_input)
           language_model=LSTM(128, return_sequences=True)(language_model)
           language_model=LSTM(128, return_sequences=True)(language_model)
          #Create the decoder
           decoder=concatenate([encoded_image, language_model])
           decoder=LSTM(512, return_sequences=True)(decoder)
           decoder=LSTM(512, return_sequences=False)(decoder)
           decoder=Dense(vocab_size, activation='softmax')(decoder)
          # Compile the model
           model=Model(inputs=[visual_input, language_input], outputs=decoder)
           optimizer=RMSprop(lr=0.0001, clipvalue=1.0)
           model.compile(loss='categorical_crossentropy', optimizer=optimizer)
          #Save the model for every 2nd epoch
           filepath="org-weights-epoch-{epoch:04d}--val_loss-{val_loss:.4f}--loss-{loss:.4f}.hdf5"
           checkpoint=ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_weights_only=True, period=2)
           callbacks_list=[checkpoint]
          # Train the model
           model.fit([image_data, X], y, batch_size=64, shuffle=False, validation_split=0.1, callbacks=callbacks_list, verbose=1, epochs=50)
          復制代碼
          

          測試準確率

          找到一種測量準確率的優(yōu)秀方法非常棘手。比如一個詞一個詞地對比,如果你的預測中有一個詞不對照,準確率可能就是 0。如果你把百分百對照的單詞移除一個,最終的準確率可能是 99/100。

          我使用的是 BLEU 分值,它在機器翻譯和圖像描述模型實踐上都是最好的。它把句子分解成 4 個 n-gram,從 1-4 個單詞的序列。在下面的預測中,「cat」應該是「code」。

          為了得到最終的分值,每個的分值需要乘以 25%,(4/5) × 0.25 + (2/4) × 0.25 + (1/3) × 0.25 + (0/2) ×0.25=0.2 + 0.125 + 0.083 + 0=0.408。然后用總和乘以句子長度的懲罰函數(shù)。因為在我們的示例中,長度是正確的,所以它就直接是我們的最終得分。

          你可以增加 n-gram 的數(shù)量,4 個 n-gram 的模型是最為對應人類翻譯的。我建議你閱讀下面的代碼:

          #Create a function to read a file and return its content
          def load_doc(filename):
           file=open(filename, 'r')
           text=file.read()
           file.close()
          return text
          def load_data(data_dir):
           text=[]
           images=[]
           files_in_folder=os.listdir(data_dir)
           files_in_folder.sort()
          for filename in tqdm(files_in_folder):
          #Add an image
          if filename[-3:]=="npz":
           image=np.load(data_dir+filename)
           images.append(image['features'])
          else:
          # Add text and wrap it in a start and end tag
           syntax='<START> ' + load_doc(data_dir+filename) + ' <END>'
          #Seperate each word with a space
           syntax=' '.join(syntax.split())
          #Add a space between each comma
           syntax=syntax.replace(',', ' ,')
           text.append(syntax)
           images=np.array(images, dtype=float)
          return images, text
          #Intialize the function to create the vocabulary
           tokenizer=Tokenizer(filters='', split=" ", lower=False)
          #Create the vocabulary in a specific order
           tokenizer.fit_on_texts([load_doc('bootstrap.vocab')])
           dir_name='../../../../eval/'
           train_features, texts=load_data(dir_name)
          #load model and weights 
           json_file=open('../../../../model.json', 'r')
           loaded_model_json=json_file.read()
           json_file.close()
           loaded_model=model_from_json(loaded_model_json)
          # load weights into new model
           loaded_model.load_weights("../../../../weights.hdf5")
          print("Loaded model from disk")
          # map an integer to a word
          def word_for_id(integer, tokenizer):
          for word, index in tokenizer.word_index.items():
          if index==integer:
          return word
          return None
          print(word_for_id(17, tokenizer))
          # generate a description for an image
          def generate_desc(model, tokenizer, photo, max_length):
           photo=np.array([photo])
          # seed the generation process
           in_text='<START> '
          # iterate over the whole length of the sequence
          print('\nPrediction---->\n\n<START> ', end='')
          for i in range(150):
          # integer encode input sequence
           sequence=tokenizer.texts_to_sequences([in_text])[0]
          # pad input
           sequence=pad_sequences([sequence], maxlen=max_length)
          # predict next word
           yhat=loaded_model.predict([photo, sequence], verbose=0)
          # convert probability to integer
           yhat=argmax(yhat)
          # map integer to word
           word=word_for_id(yhat, tokenizer)
          # stop if we cannot map the word
          if word is None:
          break
          # append as input for generating the next word
           in_text +=word + ' '
          # stop if we predict the end of the sequence
          print(word + ' ', end='')
          if word=='<END>':
          break
          return in_text
           max_length=48 
          # evaluate the skill of the model
          def evaluate_model(model, descriptions, photos, tokenizer, max_length):
           actual, predicted=list(), list()
          # step over the whole set
          for i in range(len(texts)):
           yhat=generate_desc(model, tokenizer, photos[i], max_length)
          # store actual and predicted
          print('\n\nReal---->\n\n' + texts[i])
           actual.append([texts[i].split()])
           predicted.append(yhat.split())
          # calculate BLEU score
           bleu=corpus_bleu(actual, predicted)
          return bleu, actual, predicted
           bleu, actual, predicted=evaluate_model(loaded_model, texts, train_features, tokenizer, max_length)
          #Compile the tokens into HTML and css
           dsl_path="compiler/assets/web-dsl-mapping.json"
           compiler=Compiler(dsl_path)
           compiled_website=compiler.compile(predicted[0], 'index.html')
          print(compiled_website )
          print(bleu)
          復制代碼
          

          輸出

          樣本輸出的鏈接:

          • Generated website 1 - Original 1 (emilwallner.github.io/bootstrap/r…)
          • Generated website 2 - Original 2 (emilwallner.github.io/bootstrap/r…)
          • Generated website 3 - Original 3 (emilwallner.github.io/bootstrap/r…)
          • Generated website 4 - Original 4 (emilwallner.github.io/bootstrap/r…)
          • Generated website 5 - Original 5 (emilwallner.github.io/bootstrap/r…)

          我走過的坑:

          • 理解模型的弱點而不是測試隨機模型。首先我使用隨機的東西,比如批歸一化、雙向網(wǎng)絡,并嘗試實現(xiàn)注意力機制。在查看測試數(shù)據(jù),并知道其無法高精度地預測顏色和位置之后,我意識到 CNN 存在一個弱點。這致使我使用增加的步幅來取代最大池化。驗證損失從 0.12 降至 0.02,BLEU 分值從 85% 增加至 97%。
          • 如果它們相關,則只使用預訓練模型。在小數(shù)據(jù)的情況下,我認為一個預訓練圖像模型將會提升性能。從我的實驗來看,端到端模型訓練更慢,需要更多內存,但是精確度會提升 30%。
          • 當你在遠程服務器上運行模型,我們需要為一些不同做好準備。在我的 mac 上,它按照字母表順序讀取文檔。但是在服務器上,它被隨機定位。這在代碼和截圖之間造成了不匹配。

          下一步

          前端開發(fā)是深度學習應用的理想空間。數(shù)據(jù)容易生成,并且當前深度學習算法可以映射絕大部分邏輯。一個最讓人激動的領域是注意力機制在 LSTM 上的應用。這不僅會提升精確度,還可以使我們可視化 CNN 在生成標記時所聚焦的地方。注意力同樣是標記、可定義模板、腳本和最終端之間通信的關鍵。注意力層要追蹤變量,使網(wǎng)絡可以在編程語言之間保持通信。

          但是在不久的將來,最大的影響將會來自合成數(shù)據(jù)的可擴展方法。接著你可以一步步添加字體、顏色和動畫。目前為止,大多數(shù)進步發(fā)生在草圖(sketches)方面并將其轉化為模版應用。在不到兩年的時間里,我們將創(chuàng)建一個草圖,它會在一秒之內找到相應的前端。Airbnb 設計團隊與 Uizard 已經(jīng)創(chuàng)建了兩個正在使用的原型。下面是一些可能的試驗過程:

          實驗

          開始

          • 運行所有模型
          • 嘗試不同的超參數(shù)
          • 測試一個不同的 CNN 架構
          • 添加雙向 LSTM 模型
          • 用不同數(shù)據(jù)集實現(xiàn)模型

          進一步實驗

          • 使用相應的語法創(chuàng)建一個穩(wěn)定的隨機應用/網(wǎng)頁生成器
          • 從草圖到應用模型的數(shù)據(jù)。自動將應用/網(wǎng)頁截圖轉化為草圖,并使用 GAN 創(chuàng)建多樣性。
          • 應用注意力層可視化每一預測的圖像聚焦,類似于這個模型
          • 為模塊化方法創(chuàng)建一個框架。比如,有字體的編碼器模型,一個用于顏色,另一個用于排版,并使用一個解碼器整合它們。穩(wěn)定的圖像特征是一個好的開始。
          • 饋送簡單的 HTML 組件到神經(jīng)網(wǎng)絡中,并使用 CSS 教其生成動畫。使用注意力方法并可視化兩個輸入源的聚焦將會很迷人。

          原文鏈接:blog.floydhub.com/turning-des…

          本文為機器之心編譯,轉載請聯(lián)系本公眾號獲得授權。


          主站蜘蛛池模板: 久久久久久人妻一区精品| 亚洲第一区精品观看| 无码欧精品亚洲日韩一区夜夜嗨| 精品国产日产一区二区三区| 色一情一乱一区二区三区啪啪高| 国模无码人体一区二区| 国产成人午夜精品一区二区三区| 无码人妻精品一区二区三区66| 中文字幕一区二区三区精华液| 精品一区二区三区无码免费直播| 亚洲一区二区三区久久| 无码一区二区三区免费| 亚洲人成人一区二区三区| 香蕉视频一区二区三区| 四虎永久在线精品免费一区二区| 日韩精品一区二区三区中文精品| 无码人妻视频一区二区三区| 国产一区二区三区不卡观| 国产乱码精品一区二区三区中文| 久久综合一区二区无码| 精品亚洲一区二区三区在线播放| 免费无码一区二区| 国产一区二区三区日韩精品| 日本精品啪啪一区二区三区| 国产天堂在线一区二区三区| 精品不卡一区中文字幕| 国产福利电影一区二区三区,亚洲国模精品一区 | 熟妇人妻AV无码一区二区三区| 久久免费精品一区二区| 无码免费一区二区三区免费播放| 国产午夜福利精品一区二区三区| 亚洲啪啪综合AV一区| 精品无人区一区二区三区| 国产韩国精品一区二区三区久久| 亚洲av综合av一区二区三区| 欧洲精品一区二区三区| 亚洲A∨精品一区二区三区| 国产自产V一区二区三区C| 亚洲熟妇av一区二区三区下载| 亚洲国产欧美日韩精品一区二区三区| 风间由美在线亚洲一区|