㈠ 優化演算法是什麼
什麼是智能優化演算法 10分
智能優化演算法是一種啟發式優化演算法，包括遺傳演算法、蟻群演算法、禁忌搜索演算法、模擬退火演算法、粒子群演算法等。·智能優化演算法一般是針對具體問題設計相關的演算法，理論要求弱，技術性強。一般，我們會把智能演算法與最優化演算法進行比較，相比之下，智能算浮速度快，應用性強。
傳統優化演算法和現代優化演算法包括哪些.區別是什麼
1. 傳統優化演算法一般是針對結構化的問題，有較為明確的問題和條件描述，如線性規劃，二次規劃，整數規劃，混合規劃，帶約束和不帶約束條件等，即有清晰的結構信息；而智能優化演算法一般針對的是較為普適的問題描述，普遍比較缺乏結構信息。
2. 傳統優化演算法不少都屬於凸優化范疇，有唯一明確的全局最優點；而智能優化演算法針對的絕大多數是多極值問題，如何防止陷入局部最優而盡可能找到全局最優是採納智能優化演算法的根本原因：對於單極值問題，傳統演算法大部分時候已足夠好，而智能演算法沒有任何優勢；對多極值問題，智能優化演算法通過其有效設計可以在跳出局部最優和收斂到一個點之間有個較好的平衡，從而實現找到全局最優點，但有的時候局部最優也是可接受的，所以傳統演算法也有很大應用空間和針對特殊結構的改進可能。
3. 傳統優化演算法一般是確定性演算法，有固定的結構和參數，計算復雜度和收斂性可做理論分析；智能優化演算法大多屬於啟發性演算法，能定性分析卻難定量證明，且大多數演算法基於隨機特性，其收斂性一般是概率意義上的，實際性能不可控，往往收斂速度也比較慢，計算復雜度較高。
最新的優化演算法是什麼？
這個范圍太廣了吧？列出來一篇文獻綜述都列不完
多目標優化演算法的多目標是什麼意思
多目標優化的本質在於，大多數情況下，某目標的改善可能引起其他目標性吵灶能的降低，同時使多個目標均達到最優是不可能的，只能在各目標之間進行協調權衡和折中處理，使所有目標函數盡可能達到最優，而且問題的最優解由數量眾多，甚至無窮大的Pareto最優解組成。
編程中的優化演算法問題
1. 演算法優化的過程是學習思維的過程。學習數學實質上就是學習思維。也就是說數學教育的目的不僅僅是要讓學生掌握數學知識（包括計算技能），更重要的要讓學生學會數學地思維。演算法多樣化具有很大的教學價值，學生在探究演算法多樣化的過程中，培養了思維的靈活性，發展了學生的創造性。在認識演算法多樣化的教學價值的同時，我們也認識到不同演算法的思維價值是不相等的。要充分體現演算法多樣化的教育價值，教師就應該積極引導學生優化演算法，把優化演算法的過程看作是又一次發展學生思維、培養學生能力的機會，把優化演算法變成學生又一次主動建構的學習活動。讓學生在優化演算法的過程中，通過對各種演算法的比較和分析，進行評價，不僅評價其正確升枝扮性——這樣做對嗎？而且評價其合理性——這樣做有道理嗎？還要評價其科學性——這樣做是最好的嗎？這樣的優化過程，對學生思維品質的提高無疑是十分有用的，學生在討論、交流和反思的擇優過程中逐步學會「多中擇優，優中擇簡」的數學思想方法。教師在引導學生演算法優化的過程中，幫助學生梳理思維過程，總結學習方法，養成思維習慣，形成學習能力，長此以往學生的思維品質一定能得到很大的提高。2. 在演算法優化的過程中培養學生演算法優化搭廳的意識和習慣。意識是行動的向導，有些學生因為思維的惰性而表現出演算法單一的狀態。明明自己的演算法很繁瑣，但是卻不願動腦做深入思考，僅僅滿足於能算出結果就行。要提高學生的思維水平，我們就應該有意識的激發學生思維和生活的聯系，幫助他們去除學生思維的惰性，鼓勵他們從多個角度去思考問題，然後擇優解決；鼓勵他們不能僅僅只關注於自己的演算法，還要認真傾聽他人的思考、汲取他人的長處；引導他們去感受各種不同方法的之間聯系和合理性，引導他們去感受到數學學科本身所特有的簡潔性。再演算法優化的過程中就是要讓學生感受計算方法提煉的過程，體會其中的數學思想方法，更在於讓學生思維碰撞，並形成切合學生個人實際的計算方法，從中培養學生的數學意識，使學生能自覺地運用數學思想方法來分析事物，解決問題。這樣的過程不僅是對知識技能的一種掌握和鞏固，而且可以使學生的思維更開闊、更深刻。3. 演算法優化是學生個體學習、體驗感悟、加深理解的過程。演算法多樣化是每一個學生經過自己獨立的思考和探索，各自提出的方法，從而在群體中出現了許多種演算法。因此，演算法多樣化是群體學習能力的表現，是學生集體的一題多解，而不是學生個體的多種演算法。而演算法的優化是讓學生在群體比較的過程中優化，通過交流各自得演算法，學生可以互相借鑒，互相吸收，互相補充，在個體感悟的前提下實施優化。因為優化是學生對知識結構的再構建過程，是發自學生內心的行為和自主的活動。但是，在實施演算法最優化教學時應給學生留下一定的探索空間，以及一個逐漸感悟的過程。讓學生在探索中感悟，在比較中感悟，在選擇中感悟。這樣，才利於發展學生獨立思考能力和創造能力。4. 優化演算法也是學生後繼學習的需要。小學數學是整個數學體系的基礎，是一個有著嚴密邏輯關系的子系統。演算法教學是小學數學教學的一部分，它不是一個孤立的教學點。從某一教學內容來說，也許沒有哪一種演算法是最好的、最優的，但從演算法教學的整個系統來看，必然有一種方法是最好的、最優的，是學生後繼學習所必需掌握的。在演算法多樣化的過程中，當學生提出各種演算法後，教師要及時引導學生進行比較和分析，在比較和分析的過程中感受不同策略的特點，領悟不同方法的算理，分析不同方法的優劣，做出合理的評價，從而選擇具有普遍意義的、簡捷的、並有利於後繼學習的最優方法。5. 優化也是數學學科發展的動力。數學是一門基礎學科，是一門工具學科，它的應用十分廣泛。數學之所以有如此廣泛的應用......>>
現在哪些智能優化演算法比較新
智能優化演算法是一種啟發式優化演算法，包括遺傳演算法、蟻群演算法、禁忌搜索演算法、模擬退火演算法、粒子群演算法等。·智能優化演算法一般是針對具體問題設計相關的演算法，理論要求弱，技術性強。一般，我們會把智能演算法與最優化演算法進行比較，
最新的智能優化演算法有哪些呢，論文想研究些新演算法，但是不知道哪些演算法...
答：蟻群其實還是算比較新的。 更新的也只是這些演算法的最後改進吧。演化演算法就有很多。隨便搜一篇以這些為標題，看06年以來的新文章就可以了。 各個領域都有的。否則就是到極限，也就沒有什麼研究前景了。
演算法實現函數優化是什麼意思
比如給一個函數 f(x1,x2)=x1^2+x2^2，求這個函數最小數值。。。
數學上，我們一般都是求偏導，然後一堆的，但是演算法上，我們只要使用梯度下降，幾次迭代就可以解決問題。。。
優化演算法停止條件是什麼?
適應度越大，解越優。
判斷是否已得到近似全局最優解的方法就是遺傳演算法的終止條件。 在最大迭代次數范圍內可以選擇下列條件之一作為終止條件:
1. 最大適應度值和平均適應度值變化不大、趨於穩定;
2. 相鄰GAP代種群的距離小於可接受值，參考「蔣勇，李宏.改進NSGA-II終止判斷准則[J].計算機模擬.2009. Vol.26 No.2」
智能優化演算法中cell是什麼意思
智能優化主要是用來求最優解的，通過多次迭代計算找出穩定的收斂的最優解或近似最優解，例如復雜的單模態或多模態函數的求最值問題。
㈡ 常用優化器演算法歸納介紹
優化器是神經網路訓練過程中，進行梯度下降以尋找最優解的優化方法。不同方法通過不同方式（如附加動量項，學習率自適應變化等）側重於解決不同的問題，但最終大都是為了加快訓練速度。
這里就介紹幾種常見的優化器，包括其原理、數學公式、核心思想及其性能；
核心思想： 即針對每次輸入的訓練數據，計算輸出預測與真值的Loss的梯度；
從表達式來看，網路中參數的更新，是不斷向著最小化Loss函數的方向移動的：
優點:
簡單易懂，即對於相應的最優解（這里認為是Loss的最小函數），每次變數更新都是沿著局部梯度下降最快的方向，從而最小化損失函數。
缺點:
不同於標准梯度下降法（Gradient Descent）一次計算所有數據樣本的Loss並計算相應的梯度，批量梯度下降法（BGD, Batch Gradient Descent）每次只取一個小批次的數據及其真實標簽進行訓練，稱這個批次為mini-batch；
優點：
缺點：
隨機梯度下降法的 batch size 選擇不當可能導致模型難以收斂；由於這種方法是在一次更新中，就對整個數據集計算梯度，所以計算起來非常慢，遇到很大量的數據集也會非常棘手，而且不能投入新數據實時更新模型。
我們會事先定義一個迭代次數 epoch，首先計算梯度向量 params_grad，然後沿著梯度的方向更新參數 params，learning rate 決定了我們每一步邁多大。
Batch gradient descent 對於凸函數可以收斂到全局極小值，對於非凸函數可以收斂到局部極小值。
和 BGD 的一次用所有數據計算梯度相比，SGD 每次更新時對每個樣本進行梯度更新，對於很大的數據集來說，可能會有相似的樣本，這樣 BGD 在計算梯度時會出現冗餘，而 SGD 一次只進行一次更新，就沒有冗餘，而且比較快，並且可以新增樣本。
即訓練時，每次只從一批訓練樣本中隨機選取一個樣本進行梯度下降；對隨機梯度下降來說，只需要一次關注一個訓練樣本，一點點把參數朝著全局最小值的方向進行修改了。
整體數據集是個循環，其中對每個樣本進行一次參數更新
缺點：
梯度下降速度比較慢，而且每次梯度更新時往往只專注與局部最優點，而不會恰好指向全局最優點；
單樣本梯度更新時會引入許多雜訊（跟訓練目標無關的特徵也會被歸為該樣本分類的特徵）；
SGD 因為更新比較頻繁，會造成 cost function 有嚴重的震盪。
BGD 可以收斂到局部極小值，當然 SGD 的震盪可能會跳到更好的局部極小值處。
當我們稍微減小 learning rate，SGD 和 BGD 的收斂性是一樣的。
優點：
當處理大量數據時，比如SSD或者faster-rcnn等目標檢測模型，每個樣本都有大量候選框參與訓練，這時使用隨機梯度下降法能夠加快梯度的計算。
隨機梯度下降是通過每個樣本來迭代更新一次，如果樣本量很大的情況，那麼可能只用其中部分的樣本，就已經將 迭代到最優解了，對比上面的批量梯度下降，迭代一次需要用到十幾萬訓練樣本，一次迭代不可能最優，如果迭代10次的話就需要遍歷訓練樣本10次。缺點是SGD的噪音較BGD要多，使得SGD並不是每次迭代都向著整體最優化方向。所以雖然訓練速度快，但是准確度下降，並不是全局最優。雖然包含一定的隨機性，但是從期望上來看，它是等於正確的導數的。
梯度更新規則：
MBGD 每一次利用一小批樣本，即 n 個樣本進行計算，這樣它可以降低參數更新時的方差，收斂更穩定，另一方面可以充分地利用深度學習庫中高度優化的矩陣操作來進行更有效的梯度計算。
和 SGD 的區別是每一次循環不是作用於每個樣本，而是具有 n 個樣本的批次。
超參數設定值: n 一般取值在 50～256
缺點：（兩大缺點）
鞍點就是：一個光滑函數的鞍點鄰域的曲線，曲面，或超曲面，都位於這點的切線的不同邊。例如這個二維圖形，像個馬鞍：在x-軸方嚮往上曲，在y-軸方嚮往下曲，鞍點就是（0，0）。
為了應對上面的兩點挑戰就有了下面這些演算法
核心思想：
不使用動量優化時，每次訓練的梯度下降方向，都是按照當前批次訓練數據計算的，可能並不能代表整個數據集，並且會有許多雜訊，下降曲線波動較大：
添加動量項之後，能夠有效減小波動，從而加快訓練速度：
當我們將一個小球從山上滾下來時，沒有阻力的話，它的動量會越來越大，但是如果遇到了阻力，速度就會變小。
加入的這一項，可以使得梯度方向不變的維度上速度變快，梯度方向有所改變的維度上的更新速度變慢，這樣就可以加快收斂並減小震盪。
優點：
通過動量更新，參數向量會在有持續梯度的方向上增加速度；
使梯度下降時的折返情況減輕，從而加快訓練速度；
缺點：
如果數據集分類復雜，會導致 和 時刻梯度 向量方向相差較大；在進行向量求和時，得到的 會非常小，反而使訓練速度大大下降甚至模型難以收斂。
這種情況相當於小球從山上滾下來時是在盲目地沿著坡滾，如果它能具備一些先知，例如快要上坡時，就知道需要減速了的話，適應性會更好。
目前為止，我們可以做到，在更新梯度時順應 loss function 的梯度來調整速度，並且對 SGD 進行加速。
核心思想：
自適應學習率優化演算法針對於機器學習模型的學習率，採用不同的策略來調整訓練過程中的學習率，從而大大提高訓練速度。
這個演算法就可以對低頻的參數做較大的更新，對高頻的做較小的更新，也因此，對於稀疏的數據它的表現很好，很好地提高了 SGD 的魯棒性，例如識別 Youtube 視頻裡面的貓，訓練 GloVe word embeddings，因為它們都是需要在低頻的特徵上有更大的更新。
Adagrad 的優點是減少了學習率的手動調節
式中， 表示第 個分類， 表示第 迭代同時也表示分類 累計出現的次數。 表示初始的學習率取值（一般為0.01）
AdaGrad的核心思想： 縮放每個參數反比於其所有梯度歷史平均值總和的平方根。具有代價函數最大梯度的參數相應地有較大的學習率，而具有小梯度的參數又較小的學習率。
缺點：
它的缺點是分母會不斷積累，這樣學習率就會收縮並最終會變得非常小。
這個演算法是對 Adagrad 的改進，
和 Adagrad 相比，就是分母的 換成了過去的梯度平方的衰減平均值，指數衰減平均值
這個分母相當於梯度的均方根 root mean squared (RMS)，在數據統計分析中，將所有值平方求和，求其均值，再開平方，就得到均方根值 ，所以可以用 RMS 簡寫：
其中 的計算公式如下， 時刻的依賴於前一時刻的平均和當前的梯度：
梯度更新規則:
此外，還將學習率 換成了 RMS[Δθ]，這樣的話，我們甚至都不需要提前設定學習率了：
超參數設定值: 一般設定為 0.9
RMSprop 是 Geoff Hinton 提出的一種自適應學習率方法。
RMSprop 和 Adadelta 都是為了解決 Adagrad 學習率急劇下降問題的，
梯度更新規則:
RMSprop 與 Adadelta 的第一種形式相同：（使用的是指數加權平均，旨在消除梯度下降中的擺動，與Momentum的效果一樣，某一維度的導數比較大，則指數加權平均就大，某一維度的導數比較小，則其指數加權平均就小，這樣就保證了各維度導數都在一個量級，進而減少了擺動。允許使用一個更大的學習率η）
超參數設定值:
Hinton 建議設定 為 0.9, 學習率 為 0.001。
這個演算法是另一種計算每個參數的自適應學習率的方法。相當於 RMSprop + Momentum
除了像 Adadelta 和 RMSprop 一樣存儲了過去梯度的平方 vt 的指數衰減平均值 ，也像 momentum 一樣保持了過去梯度 mt 的指數衰減平均值：
如果 和 被初始化為 0 向量，那它們就會向 0 偏置，所以做了偏差校正，通過計算偏差校正後的 和 來抵消這些偏差：
梯度更新規則:
超參數設定值:
建議
示例一
示例二
示例三
上面情況都可以看出，Adagrad, Adadelta, RMSprop 幾乎很快就找到了正確的方向並前進，收斂速度也相當快，而其它方法要麼很慢，要麼走了很多彎路才找到。
由圖可知自適應學習率方法即 Adagrad, Adadelta, RMSprop, Adam 在這種情景下會更合適而且收斂性更好。
如果數據是稀疏的，就用自適用方法，即 Adagrad, Adadelta, RMSprop, Adam。
RMSprop, Adadelta, Adam 在很多情況下的效果是相似的。
Adam 就是在 RMSprop 的基礎上加了 bias-correction 和 momentum，
隨著梯度變的稀疏，Adam 比 RMSprop 效果會好。
整體來講，Adam 是最好的選擇。
很多論文里都會用 SGD，沒有 momentum 等。SGD 雖然能達到極小值，但是比其它演算法用的時間長，而且可能會被困在鞍點。
如果需要更快的收斂，或者是訓練更深更復雜的神經網路，需要用一種自適應的演算法。
各種優化器Optimizer原理：從SGD到AdamOptimizer
深度學習——優化器演算法Optimizer詳解（BGD、SGD、MBGD、Momentum、NAG、Adagrad、Adadelta、RMSprop、Adam）
㈢ 求多個矩陣聯乘的最優演算法!
程序功能：用分而治之演算法計算兩個n維矩陣相乘的結果
其中n必須是2的正整數次冪。
運行過程：首先，根據提示輸入矩陣的維數n
其次，根據提示分別輸入矩陣A和B
最後，顯示矩陣A和矩陣B以及其相乘結果矩陣C
****************************************/
#include "stdio.h"
#define mytype int//矩陣元素的數據類型
#define myinputmode "%d"//矩陣元素的輸入格式
#define myprintmode "%4d"//矩陣元素的輸出格式
/*以上參數的設置可根據所計算矩陣的元素的數值類型進行相應改變
如更改為浮點型數據則可以使用下面的設置
#define mytype float
#define myinputmode "%f"
#define myprintmode "%6.2f"
*/
/////////////////////////////////////////
/****************************************
函數名：is2
參數：m為長整型整數
功能：檢測m是否是2的正整數次冪
返回值：返回布爾型變數
true則表示m為2的正整數次冪
false則表示m不是2的正整數次冪
****************************************/
bool is2(long m)
{
if(m<0)return false;
if(m>=2)
{
if((m%2)==0) return is2(m/2);
else return false;
}
else
{
if(m==1)return true;
else return false;
}
return false;
}
/////////////////////////////////////////
/****************************************
函數名：inputmatrix
參數：M為指向數組的指針，用來存儲輸入的矩陣
m長整型，是數組M所存矩陣的維數
name字元型數組，是需要進行數據輸入的矩陣的名字
功能：矩陣數據輸入的函數，通過輸入矩陣的每個元素將
矩陣存入數組
返回值：無
****************************************/
void inputmatrix(mytype * M,long m,char *name)
{
long i,j;
for(i=0;i<m;i++)
for(j=0;j<m;j++)
{
printf("Please input the %s(%d,%d):",name,i+1,j+1);
getchar();
scanf(myinputmode,&M[i*m+j]);
}
}
/////////////////////////////////////////
/****************************************
函數名：printmatrix
參數：M為指向數組的指針，數組中存儲著矩陣
m長整型，是數組M所存矩陣的維數
name字元型數組，是需要進行數據輸入的矩陣的名字
功能：矩陣數據輸出顯示的函數，將矩陣元素一一顯示一在屏幕上
返回值：無
****************************************/
void printmatrix(mytype * M,long m,char *name)
{
long i,j;
printf("\nMatrix %s:\n",name);
for(i=0;i<m;i++)
{
for(j=0;j<m;j++)
{
printf(myprintmode,M[i*m+j]);
}
printf("\n");
}
}
/////////////////////////////////////////
/****************************************
函數名：Matrix_add_sub
參數：A，B為指向數組的指針，數組中存儲著矩陣
C為指向數組的指針，用來存儲運算結果
m長整型，是數組A、B、C所存矩陣的維數
add為布爾型變數，為true則C=A+B，為false則C=A-B
功能：根據add值對A、B進行加減運算並將結果存入C
返回值：無
****************************************/
void Matrix_add_sub(mytype * A,mytype * B,mytype * C,long m,bool add)
{
long i;
for(i=0;i<m*m;i++)
{
if(add)
C[i]=A[i]+B[i];
else
C[i]=A[i]-B[i];
}
}
/////////////////////////////////////////
/****************************************
函數名：GetHalfValue
參數：B為指向數組的指針，數組中存儲著矩陣。其中B是指向m維矩陣中的一個元素。
A為指向數組的指針，用來接收B中的四分之一數據
m長整型，是數組B所指矩陣的維數
功能：從B所在位置向左和向右取矩陣的m/2維的子矩陣（子矩陣中包括B所指元素）並存入A
返回值：無
****************************************/
void GetHalfValue(mytype * A,mytype * B,long m)
{
long i,j;
for(i=0;i<m/2;i++)
{
for(j=0;j<m/2;j++)
{
A[i*m/2+j]=B[i*m+j];
}
}
}
/////////////////////////////////////////
/****************************************
函數名：UpdateHalfValue
參數：B為指向數組的指針，數組中存儲著矩陣。其中B是指向m維矩陣中的一個元素。
A為指向數組的指針，存儲著一個m/2維矩陣
m長整型，是數組B所指矩陣的維數
功能：把A矩陣所有元素存入從B所在位置向左和向右的m/2維的子矩陣（子矩陣中包括B所指元素）
返回值：無
****************************************/
void UpdateHalfValue(mytype * A,mytype * B,long m)
{
long i,j;
for(i=0;i<m/2;i++)
{
for(j=0;j<m/2;j++)
{
B[i*m+j]=A[i*m/2+j];
}
}
}
/////////////////////////////////////////
/****************************************
函數名：Matrix_multiplication
參數：A，B為指向數組的指針，數組中存儲著矩陣。
C為指向數組的指針，用來存儲計算結果
m長整型，是指針A、B所指矩陣的維數
功能：用分而治之演算法和Strassen方法計算A與B的乘積並存入C
返回值：無
****************************************/
void Matrix_multiplication(mytype * A,mytype * B,mytype * C,long m)
{
if(m>2)//當矩陣維數大於2時
{
//將矩陣A、B分為四個小矩陣，分別為A1、A2、A3、A4、B1、B2、B3、B4
mytype *A1=new mytype[m*m/4],*A2=new mytype[m*m/4],*A3=new mytype[m*m/4],*A4=new mytype[m*m/4],*B1=new mytype[m*m/4],*B2=new mytype[m*m/4],*B3=new mytype[m*m/4],*B4=new mytype[m*m/4],*C1=new mytype[m*m/4],*C2=new mytype[m*m/4],*C3=new mytype[m*m/4],*C4=new mytype[m*m/4];
GetHalfValue(A1,&A[0],m);
GetHalfValue(A2,&A[m/2],m);
GetHalfValue(A3,&A[m*m/2],m);
GetHalfValue(A4,&A[m*m/2+m/2],m);
GetHalfValue(B1,&B[0],m);
GetHalfValue(B2,&B[m/2],m);
GetHalfValue(B3,&B[m*m/2],m);
GetHalfValue(B4,&B[m*m/2+m/2],m);
//利用Strassen方法計算D、E、F、G、H、I、J
mytype *D=new mytype[m*m/4],*E=new mytype[m*m/4],*F=new mytype[m*m/4],*G=new mytype[m*m/4],*H=new mytype[m*m/4],*I=new mytype[m*m/4],*J=new mytype[m*m/4];
mytype *temp1=new mytype[m*m/4],*temp2=new mytype[m*m/4];
//D=A1(B2-B4)
Matrix_add_sub(B2,B4,temp1,m/2,false);
Matrix_multiplication(A1,temp1,D,m/2);
//E=A4(B3-B1)
Matrix_add_sub(B3,B1,temp1,m/2,false);
Matrix_multiplication(A4,temp1,E,m/2);
//F=(A3+A4)B1
Matrix_add_sub(A3,A4,temp1,m/2,true);
Matrix_multiplication(temp1,B1,F,m/2);
//G=(A1+A2)B4
Matrix_add_sub(A1,A2,temp1,m/2,true);
Matrix_multiplication(temp1,B4,G,m/2);
//H=(A3-A1)(B1+B2)
Matrix_add_sub(A3,A1,temp1,m/2,false);
Matrix_add_sub(B1,B2,temp2,m/2,true);
Matrix_multiplication(temp1,temp2,H,m/2);
//I=(A2-A4)(B3+B4)
Matrix_add_sub(A2,A4,temp1,m/2,false);
Matrix_add_sub(B3,B4,temp2,m/2,true);
Matrix_multiplication(temp1,temp2,I,m/2);
//J=(A1+A4)(B1+B4)
Matrix_add_sub(A1,A4,temp1,m/2,true);
Matrix_add_sub(B1,B4,temp2,m/2,true);
Matrix_multiplication(temp1,temp2,J,m/2);
//利用Strassen方法計算C1、C2、C3、C4
//C1=E+I+J-G
Matrix_add_sub(E,I,temp1,m/2,true);
Matrix_add_sub(J,G,temp2,m/2,false);
Matrix_add_sub(temp1,temp2,C1,m/2,true);
//C2=D+G
Matrix_add_sub(D,G,C2,m/2,true);
//C3=E+F
Matrix_add_sub(E,F,C3,m/2,true);
//C4=D+H+J-F
Matrix_add_sub(D,H,temp1,m/2,true);
Matrix_add_sub(J,F,temp2,m/2,false);
Matrix_add_sub(temp1,temp2,C4,m/2,true);
//將計算結果存入數組C
UpdateHalfValue(C1,&C[0],m);
UpdateHalfValue(C2,&C[m/2],m);
UpdateHalfValue(C3,&C[m*m/2],m);
UpdateHalfValue(C4,&C[m*m/2+m/2],m);
//釋放內存
delete[] A1,A2,A3,A4,B1,B2,B3,B4,C1,C2,C3,C4,D,E,F,G,H,I,J,temp1,temp2;
}
else
{
//當矩陣維數小於2時用Strassen方法計算矩陣乘積
mytype D,E,F,G,H,I,J;
//D=A1(B2-B4)
D=A[0]*(B[1]-B[3]);
//E=A4(B3-B1)
E=A[3]*(B[2]-B[0]);
//F=(A3+A4)B1
F=(A[2]+A[3])*B[0];
//G=(A1+A2)B4
G=(A[0]+A[1])*B[3];
//H=(A3-A1)(B1+B2)
H=(A[2]-A[0])*(B[0]+B[1]);
//I=(A2-A4)(B3+B4)
I=(A[1]-A[3])*(B[2]+B[3]);
//J=(A1+A4)(B1+B4)
J=(A[0]+A[3])*(B[0]+B[3]);
//C1=E+I+J-G
C[0]=E+I+J-G;
//C2=D+G
C[1]=D+G;
//C3=E+F
C[2]=E+F;
//C4=D+H+J-F
C[3]=D+H+J-F;
}
}
/////////////////////////////////////////
int main()
{
long n;
//提示輸入n維矩陣的維數
printf("Please input the dimension of the Matrix.(n):");
//獲得用戶輸入的n維矩陣維數
scanf("%d",&n);
while(!is2(n))//檢查維數是否是2的冪，不是則要求重新輸入
{
printf("Please reinput the dimension of the Matrix.(n):");
scanf("%d",&n);
}
//開辟空間存儲用來存儲n維矩陣元素
mytype *A=new mytype[n*n];
mytype *B=new mytype[n*n];
mytype *C=new mytype[n*n];
//輸入矩陣A、B
inputmatrix(A,n,"A");
inputmatrix(B,n,"B");
if(n>1)//矩陣維數大於1則用分而治之演算法計算
Matrix_multiplication(A,B,C,n);
else//矩陣維數為1則直接計算
*C=(*A)*(*B);
//輸出矩陣A、B、C
printmatrix(A,n,"A");
printmatrix(B,n,"B");
printmatrix(C,n,"C");
//釋放內存
delete[] A,B,C;
getchar();getchar();
return 1;
}
㈣ 優化演算法總結
本文介紹一下機器學習和深度學習中常用的優化演算法和優化器以及一些其他我知道的優化演算法,部分演算法我也沒有搞懂,就先記錄下來以後慢慢研究吧.*_*.
1.梯度下降演算法(Gradient Descent)
梯度下降法可以參考我另一篇文章 機器學習-線性回歸 里的講解,這里就不在重復敘述.這里需要強調一下,深度學習里常用的SGD,翻譯過來是隨機梯度下降,但是實質是mini-batch梯度下降(mini-batch-gd),或者說是兩者的結合更准確一些.
SGD的優點是,演算法簡單,計算量小,在函數為凸函數時可以找到全局最優解.所以是最常用的優化演算法.缺點是如果函數不是凸函數的話,很容易進入到局部最優解而無法跳出來.同時SGD在選擇學習率上也是比較困難的.
2.牛頓法
牛頓法和擬牛頓法都是求解無約束最優化問題的常用方法,其中牛頓法是迭代演算法,每一步需要求解目標函數的海森矩陣的逆矩陣,計算比較復雜.
牛頓法在求解方程根的思想:在二維情況下,迭代的尋找某一點x,尋找方法是隨機一個初始點x_0,目標函數在該點x_0的切線與x坐標軸的交點就是下一個x點,也就是x_1.不斷迭代尋找x.其中切線的斜率為目標函數在點x_0的導數(梯度),切必過點(x_0,f(x_0)).所以迭代的方程式如圖1,為了求該方程的極值點,還需要令其導數等於0,也就是又求了一次導數,所以需要用到f(x)的二階導數.
在最優化的問題中,牛頓法提供了一種求解的辦法. 假設任務是優化一個目標函數f, 求函數ff的極大極小問題, 可以轉化為求解函數f導數等於0的問題, 這樣求可以把優化問題看成方程求解問題(f的導數等於0). 剩下的問題就和牛頓法求解方程根的思想很相似了.
目標函數的泰勒展開式:
化簡後:
這樣就得到了與圖1相似的公式,這里是二維的,在多維空間上,求二階導數就是求海森矩陣,因為是分母,所以還需要求海森矩陣的逆矩陣.
牛頓法和SGD的區別:
牛頓法是二階求導,SGD是一階求導,所以牛頓法要收斂的更快一些.SGD只考慮當前情況下梯度下降最快的方向,而牛頓法不僅考慮當前梯度下降最快,還有考慮下一步下降最快的方向.
牛頓法的優點是二階求導下降速度快,但是因為是迭代演算法,每一步都需要求解海森矩陣的逆矩陣,所以計算復雜.
3.擬牛頓法(沒搞懂,待定)
考慮到牛頓法計算海森矩陣比較麻煩,所以它使用正定矩陣來代替海森矩陣的逆矩陣,從而簡化了計算過程.
常用的擬牛頓法有DFP演算法和BFGS演算法.
4.共軛梯度法(Conjugate Gradient)
共軛梯度法是介於最速下降法與牛頓法之間的一個方法,它僅需利用一階導數信息,但克服了最速下降法收斂慢的缺點,又避免了牛頓法計算海森矩陣並求逆的缺點.共軛梯度法不僅是解決大型線性方程組最有用的方法之一,也是解大型非線性最優化最有效的演算法之一.
5.拉格朗日法
參考SVM里的講解 機器學習-SVM
6.動量優化法(Momentum)
動量優化法主要是在SGD的基礎上,加入了歷史的梯度更新信息或者說是加入了速度更新.SGD雖然是很流行的優化演算法,但是其學習過程很慢,因為總是以同樣的步長沿著梯度下降的方向.所以動量是為了加速學習的方法.
其中第一行的減號部分是計算當前的梯度,第一行是根據梯度更新速度v,而α是新引進的參數,在實踐中,α的一般取值為 0.5,0.9 和 0.99.和學習率 一樣,α 也會隨著時間不斷調整.一般初始值是一個較小的值,隨後會慢慢變大.
7.Nesterov加速梯度(NAG, Nesterov accelerated gradient)
NAG是在動量優化演算法的基礎上又進行了改進.根據下圖可以看出,Nesterov 動量和標准動量之間的區別體現在梯度計算上, Nesterov 動量中,梯度計算在施加當前速度之後.因此,Nesterov 動量可以解釋為往標准動量方法中添加了一個校正因子
8.AdaGrad演算法
AdaGrad演算法,自適應優化演算法的一種,獨立地適應所有模型參數的學習率,縮放每個參數反比於其所有梯度歷史平均值總和的平方根.具有代價函數最大梯度的參數相應地有個快速下降的學習率,而具有小梯度的參數在學習率上有相對較小的下降.通俗一點的講,就是根據實際情況更改學習率,比如模型快要收斂的時候,學習率步長就會小一點,防止跳出最優解.
其中g是梯度,第一行的分母是計算累計梯度的平方根, 是為了防止分母為0加上的極小常數項,α是學習率.
Adagrad的主要優點是不需要人為的調節學習率,它可以自動調節.但是依然需要設置一個初始的全局學習率.缺點是隨著迭代次數增多,學習率會越來越小,最終會趨近於0.
9.RMSProp演算法
RMSProp修改 AdaGrad 以在非凸設定下效果更好,改變梯度積累為指數加權的移動平均.AdaGrad旨在應用於凸問題時快速收斂.
10.AdaDelta演算法
11.Adam演算法
Adam是Momentum和RMSprop的結合體,也就是帶動量的自適應優化演算法.
12.Nadam演算法
13.模擬退火演算法
14.蟻群演算法
15.遺傳演算法
動量是為了加快學習速度,而自適應是為了加快收斂速度,注意學習速度快不一定收斂速度就快,比如步長大學習速度快,但是很容易跳出極值點,在極值點附近波動,很難達到收斂.
未完待定....
參考:
《統計學習方法》 李航 著
《深度學習》 花書
㈤ 幾種常用最優化方法
學習和工作中遇到的大多問題都可以建模成一種最優化模型進行求解，比如我們現在學習的機器學習演算法，大部分的機器學習演算法的本質都是建立優化模型，通過最優化方法對目標函數（或損失函數）進行優化，從而訓練出最好的模型。常見的優化方法(optimization)有梯度下降法、牛頓法和擬牛頓法、共軛梯度法等等。
1. 梯度下降法（Gradient Descent）
梯度下降法是最早最簡單，也是最為常用的最優化方法。梯度下降法實現簡單，當目標函數是凸函數時，梯度下降法的解是全局解。一般情況下，其解不保證是全局最優解，梯度下降法的速度也未必是最快的。 梯度下降法的優化思想是用當前位置負梯度方向作為搜索方向，因為該方向為當前位置的最快下降方向，所以也被稱為是」最速下降法「。最速下降法越接近目標值，步長越小，前進越慢。
梯度下降 法的缺點：
（1）靠近極小值時收斂速度減慢;
（2）直線搜索時可能會產生一些問題；
（3）可能會「之字形」地下降。
在機器學習中，基於基本的梯度下降法發展了兩種梯度下降方法，分別為隨機梯度下降法和批量梯度下降法。
比如對一個線性回歸（Linear Logistics）模型，假設下面的h(x)是要擬合的函數，J( )為損失函數， 是參數，要迭代求解的值，求解出來了那最終要擬合的函數h( )就出來了。其中m是訓練集的樣本個數，n是特徵的個數。
1）批量梯度下降法（Batch Gradient Descent，BGD）
（1）將J( )對 求偏導，得到每個theta對應的的梯度：
(2）由於是要最小化風險函數，所以按每個參數 的梯度負方向，來更新每個 ：
（3）從上面公式可以注意到，它得到的是一個全局最優解，但是每迭代一步，都要用到訓練集所有的數據，如果m很大，那麼可想而知這種方法的迭代速度會相當的慢。所以，這就引入了另外一種方法——隨機梯度下降。
對於批量梯度下降法，樣本個數m，x為n維向量，一次迭代需要把m個樣本全部帶入計算，迭代一次計算量為m*n2。
2）隨機梯度下降（Stochastic Gradient Descent，SGD）
（1）上面的風險函數可以寫成如下這種形式，損失函數對應的是訓練集中每個樣本的粒度，而上面批量梯度下降對應的是所有的訓練樣本：
（2）每個樣本的損失函數，對 求偏導得到對應梯度，來更新 ：
（3）隨機梯度下降是通過每個樣本來迭代更新一次，如果樣本量很大的情況（例如幾十萬），那麼可能只用其中幾萬條或者幾千條的樣本，就已經將
迭代到最優解了，對比上面的批量梯度下降，迭代一次需要用到十幾萬訓練樣本，一次迭代不可能最優，如果迭代10次的話就需要遍歷訓練樣本10次。但是，SGD伴隨的一個問題是噪音較BGD要多，使得SGD並不是每次迭代都向著整體最優化方向。
隨機梯度下降每次迭代只使用一個樣本，迭代一次計算量為n2，當樣本個數m很大的時候，隨機梯度下降迭代一次的速度要遠高於批量梯度下降方法。 兩者的關系可以這樣理解：隨機梯度下降方法以損失很小的一部分精確度和增加一定數量的迭代次數為代價，換取了總體的優化效率的提升。增加的迭代次數遠遠小於樣本的數量。
對批量梯度下降法和隨機梯度下降法的總結：
批量梯度下降---最小化所有訓練樣本的損失函數，使得最終求解的是全局的最優解，即求解的參數是使得風險函數最小，但是對於大規模樣本問題效率低下。
隨機梯度下降---最小化每條樣本的損失函數，雖然不是每次迭代得到的損失函數都向著全局最優方向， 但是大的整體的方向是向全局最優解的，最終的結果往往是在全局最優解附近，適用於大規模訓練樣本情況。
2. 牛頓法和擬牛頓法（Newton's method & Quasi-Newton Methods）
1）牛頓法（Newton's method）
牛頓法是一種在實數域和復數域上近似求解方程的方法。方法使用函數 f ( x )的泰勒級數的前面幾項來尋找方程 f ( x ) = 0的根。牛頓法最大的特點就在於它的收斂速度很快。
具體步驟：
首先，選擇一個接近函數 f ( x )零點的x0，計算相應的 f ( x 0)和切線斜率 f ' ( x 0)（這里 f ' 表示函數 f 的導數）。然後我們計算穿過點( x 0, f ( x 0))並且斜率為 f '( x 0)的直線和 x 軸的交點的 x 坐標，也就是求如下方程的解：
我們將新求得的點的 x 坐標命名為 x 1，通常 x 1會比 x 0更接近方程 f ( x ) = 0的解。因此我們現在可以利用 x 1開始下一輪迭代。迭代公式可化簡為如下所示：
已經證明，如果 f '是連續的，並且待求的零點 x 是孤立的，那麼在零點 x 周圍存在一個區域，只要初始值 x 0位於這個鄰近區域內，那麼牛頓法必定收斂。 並且，如果 f ' ( x )不為0, 那麼牛頓法將具有平方收斂的性能. 粗略的說，這意味著每迭代一次，牛頓法結果的有效數字將增加一倍。下圖為一個牛頓法執行過程的例子。
由於牛頓法是基於當前位置的切線來確定下一次的位置，所以牛頓法又被很形象地稱為是"切線法"。
關於牛頓法和梯度下降法的效率對比：
從本質上去看，牛頓法是二階收斂，梯度下降是一階收斂，所以牛頓法就更快。如果更通俗地說的話，比如你想找一條最短的路徑走到一個盆地的最底部，梯度下降法每次只從你當前所處位置選一個坡度最大的方向走一步，牛頓法在選擇方向時，不僅會考慮坡度是否夠大，還會考慮你走了一步之後，坡度是否會變得更大。所以，可以說牛頓法比梯度下降法看得更遠一點，能更快地走到最底部。（牛頓法目光更加長遠，所以少走彎路；相對而言，梯度下降法只考慮了局部的最優，沒有全局思想。）
根據wiki上的解釋，從幾何上說，牛頓法就是用一個二次曲面去擬合你當前所處位置的局部曲面，而梯度下降法是用一個平面去擬合當前的局部曲面，通常情況下，二次曲面的擬合會比平面更好，所以牛頓法選擇的下降路徑會更符合真實的最優下降路徑。
註：紅色的牛頓法的迭代路徑，綠色的是梯度下降法的迭代路徑。
牛頓法的優缺點總結：
優點：二階收斂，收斂速度快；
缺點：牛頓法是一種迭代演算法，每一步都需要求解目標函數的Hessian矩陣的逆矩陣，計算比較復雜。
2）擬牛頓法（Quasi-Newton Methods）
擬牛頓法是求解非線性優化問題最有效的方法之一，於20世紀50年代由美國Argonne國家實驗室的物理學家W.C.Davidon所提出來。Davidon設計的這種演算法在當時看來是非線性優化領域最具創造性的發明之一。不久R. Fletcher和M. J. D. Powell證實了這種新的演算法遠比其他方法快速和可靠，使得非線性優化這門學科在一夜之間突飛猛進。
擬牛頓法的本質思想是改善牛頓法每次需要求解復雜的Hessian矩陣的逆矩陣的缺陷，它使用正定矩陣來近似Hessian矩陣的逆，從而簡化了運算的復雜度。 擬牛頓法和最速下降法一樣只要求每一步迭代時知道目標函數的梯度。通過測量梯度的變化，構造一個目標函數的模型使之足以產生超線性收斂性。這類方法大大優於最速下降法，尤其對於困難的問題。另外，因為擬牛頓法不需要二階導數的信息，所以有時比牛頓法更為有效。如今，優化軟體中包含了大量的擬牛頓演算法用來解決無約束，約束，和大規模的優化問題。
具體步驟：
擬牛頓法的基本思想如下。首先構造目標函數在當前迭代xk的二次模型：
這里Bk是一個對稱正定矩陣，於是我們取這個二次模型的最優解作為搜索方向，並且得到新的迭代點：
其中我們要求步長ak 滿足Wolfe條件。這樣的迭代與牛頓法類似，區別就在於用近似的Hesse矩陣Bk 代替真實的Hesse矩陣。所以擬牛頓法最關鍵的地方就是每一步迭代中矩陣Bk的更新。現在假設得到一個新的迭代xk+1，並得到一個新的二次模型：
我們盡可能地利用上一步的信息來選取Bk。具體地，我們要求
從而得到
這個公式被稱為割線方程。常用的擬牛頓法有DFP演算法和BFGS演算法。
原文鏈接： [Math] 常見的幾種最優化方法 - Poll的筆記 - 博客園