最優化函數python

⑴ #python干貨#python實現——最優化演算法

函數詳見rres，此代碼使該演算法運行了兩次

收獲：
這是我第一個實現的代碼。學習完該演算法以後，邏輯框架基本上就有了，剩下需要明確的就是對應的python的語言。於是我就開始了查找「如何定義函數」（詳見mofan的優酷），「循環體」和「if條件語句」的格式（https://blog.csdn.net/qq_39407518/article/details/79822498）「數學符號」（詳見mofan的優酷），以及print的使用

1.def是python中指定義，一般用來定義函數，如果需要深度學習搭建網路可用來定義網路。值得注意的一點是

我不清楚為什麼，但是如果沒有加的話，那個函數公式就是一個花瓶，就像一個結果輸不出去。

2.最坑的就是邏輯。一開始邏輯沒理清楚，或者說在代碼上有疏漏，導致我將left和right放在了循環體里，結果可想而知。不過也是因為這個錯誤，我知道pycharm中的debug怎麼用，挺簡單的，網路一下就出來了。

3.不知道什麼原因，看的莫煩視頻中的print多個變數一起輸出是沒有辦法在我的pycharm中使用的，出來的結果很奇怪。可能是因為我是win10不是ios吧。print如果多個變數一起輸出必須是print("名字：%s,名字2：%s"%(a,b))結果輸出就是名字：a ,名字2：b

關於python中數據變數。第一遍運行結果出現很明顯不對，於是我採用了debug。結果發現，mid1處一直為1而不是1.5，於是就開始了解數據變數。起初我猜測python默認所有變數為整型，但是根據二分法的結果我意識到此猜測不對，所以要改整個file的變數格式沒有必要。所以我就在mid1式子前面加了一個float，結果就顯示為1.5了。但是如果我將整個式子用（）括起來，前面加float，結果還是1。我不太理解為什麼。不過我知道了python的數據格式是根據輸入量決定的，也就是說你的輸入量如果是整型，那麼與其直接相關的計算輸出結果一定是整型，而且還是不採用進位的整型。在我沒有採用+float/+.0這兩種方法之前，mid1~3全部是整型。

或者不再mid1前面加float,直接將輸入量後面點個點就行
真的很想吐槽一下print,好麻煩啊啊啊啊每次都得弄個%s,而且有時候還不能放一起！！！！

不要問我掌握了什麼，要問我現在寫完這個代碼後有多麼的愛python的精度表示 :-)我決定以後只要再編寫數學公式的代碼都將輸入量的小數學點後面補很多0
fibonacci函數定義，每次debug後我的手都是抖的O( _ )O~

不知道自己什麼時候有的強迫症，只要是代碼下面有「~」我就必須要消掉。笑哭。這個很簡單，前四個除了費波納茨，都很簡單。

這個公式看起來很麻煩，便寫的時候更要謹慎。我上回把那個2擱在了分號下面，結果很大，所以還是換算成0.5更好（PS：勿忘那長河般的0）。
雖然代碼很長，但是主要是因為print太多。本打算在開頭print，最後結果會漏掉最後一部分。懶得想其他辦法了，直接就這樣吧

一開始while裡面寫成了>,導致run不出來。繼而，debug也沒法用。在網上一查才知道 「沒聯網」+「沒選斷點」。最後想嘗試將else裡面的內容輸出來，結果發現run以後被刷屏了。於是改成i<7以後還是不行，於是想著加一個break跳出循環，結果成效了。
然後剛剛由debug了一下，才知道原來是i+1在if裡面，因為沒有辦法+1，所以i=6一直存在，就不斷循環。因為加break也好，i+1也好，都可以。

這是我第一組自己實現的python代碼，就是數學公式用python語言組裝起來。剛開始的時候知道大概需要在語言中體現什麼，但不太清楚。於是我就在網上找了幾個二分法的，他們都各有不同，但框架都差不多，不過如果要用到我們的那個公式里還需要改變很多。然後我就開始分析我們的題，我發現大體需要兩部分，一部分函數定義，一部分循環體。但我不知道如何定義函數，如何寫數學公式，如何弄變數，也就是說一些小點不太會，所以我選擇直接網路。因為我知道自己閱讀的能力不錯，相比於從視頻中提取要素，我更擅長通過閱讀獲得要點。有目的性地找知識點，掌握地更牢固。
於是我就開始了第一個——二分法的編寫。我發現，自己出現了很多錯誤而且有很多地方都很基礎。但我依然沒選擇視頻，而是將這些問題直接在網路上找，因為視頻講完或許你也沒找到點。當然，這是一步一步走的，不是直接就將程序擺上去，一點一點改。
隨著前兩個的成功，我發現自己對於這些代碼有了自信，似乎看透了他們的偽裝，抓住了本質。除此之外，我還意識到自己自從8月份以後，學習能力似乎提高了不少，而且有了更為有效的學習方法。各方面都有了一定的覺醒。除了第一個找了幾個牛頭不對馬嘴的代碼，其他都是根據自己的邏輯寫，邏輯通下來以後，對應語言中某一部分不知道如何翻譯就去網路，其實這幾個套路都一樣或者說數學公式轉化的套路都一樣。
我還意識到，匯編其實是最難的語言，目前為止所學到的，因為很多都需要自己去定義，去死摳，需要記住大量的指令且不能靈活變通。但是其他的卻只需要將一些對應的記下來就好。python真的挺簡單的。而且，我發現自己今天似乎打開了新世界的大門，我愛上了這種充滿了靈性的東西，充滿了嚴謹的美麗，還有那未知的變化，我發現我似乎愛上了代碼。可能不僅僅局限於python，這些語言都充滿了挑戰性。我覺得當你疑惑的時候，就需要相信直覺，至少我發現它很准

⑵ 優化Python編程的4個妙招

1. Pandas.apply() – 特徵工程瑰寶

Pandas 庫已經非常優化了，但是大部分人都沒有發揮它的最大作用。想想它一般會用於數據科學項目中的哪些地方。一般首先能想到的就是特徵工程，即用已有特徵創造新特徵。其中最高效的方法之一就是Pandas.apply()，即Pandas中的apply函數。

在Pandas.apply()中，可以傳遞用戶定義功能並將其應用到Pandas Series的所有數據點中。這個函數是Pandas庫最好的擴展功能之一，它能根據所需條件分隔數據。之後便能將其有效應用到數據處理任務中。

2. Pandas.DataFrame.loc – Python數據操作絕妙技巧

所有和數據處理打交道的數據科學家(差不多所有人了!)都應該學會這個方法。

很多時候，數據科學家需要根據一些條件更新數據集中某列的某些值。Pandas.DataFrame.loc就是此類問題最優的解決方法。

3. Python函數向量化

另一種解決緩慢循環的方法就是將函數向量化。這意味著新建函數會應用於輸入列表，並返回結果數組。在Python中使用向量化能至少迭代兩次，從而加速計算。

事實上，這樣不僅能加速代碼運算，還能讓代碼更加簡潔清晰。

4. Python多重處理

多重處理能使系統同時支持一個以上的處理器。

此處將數據處理分成多個任務，讓它們各自獨立運行。處理龐大的數據集時，即使是apply函數也顯得有些遲緩。

關於優化Python編程的4個妙招，青藤小編就和您分享到這里了。如果您對python編程有濃厚的興趣，希望這篇文章可以為您提供幫助。如果您還想了解更多關於python編程的技巧及素材等內容，可以點擊本站的其他文章進行學習。

⑶ Python怎麼做最優化

一、概觀scipy中的optimize子包中提供了常用的最優化演算法函數實現。我們可以直接調用這些函數完成我們的優化問題。optimize中函數最典型的特點就是能夠從函數名稱上看出是使用了什麼演算法。下面optimize包中函數的概覽：1.非線性最優化fmin -- 簡單Nelder-Mead演算法fmin_powell -- 改進型Powell法fmin_bfgs -- 擬Newton法fmin_cg -- 非線性共軛梯度法fmin_ncg -- 線性搜索Newton共軛梯度法leastsq -- 最小二乘2.有約束的多元函數問題fmin_l_bfgs_b ---使用L-BFGS-B演算法fmin_tnc ---梯度信息fmin_cobyla ---線性逼近fmin_slsqp ---序列最小二乘法nnls ---解|| Ax - b ||_2 for x=03.全局優化anneal ---模擬退火演算法brute --強力法4.標量函數fminboundbrentgoldenbracket5.擬合curve_fit-- 使用非線性最小二乘法擬合6.標量函數求根brentq ---classic Brent (1973)brenth ---A variation on the classic Brent（1980）ridder ---Ridder是提出這個演算法的人名bisect ---二分法newton ---牛頓法fixed_point7.多維函數求根fsolve ---通用broyden1 ---Broyden』s first Jacobian approximation.broyden2 ---Broyden』s second Jacobian approximationnewton_krylov ---Krylov approximation for inverse Jacobiananderson ---extended Anderson mixingexcitingmixing ---tuned diagonal Jacobian approximationlinearmixing ---scalar Jacobian approximationdiagbroyden ---diagonal Broyden Jacobian approximation8.實用函數line_search ---找到滿足強Wolfe的alpha值check_grad ---通過和前向有限差分逼近比較檢查梯度函數的正確性二、實戰非線性最優化fmin完整的調用形式是：fmin(func, x0, args=(), xtol=0.0001, ftol=0.0001, maxiter=None, maxfun=None, full_output=0, disp=1, retall=0, callback=None)不過我們最常使用的就是前兩個參數。一個描述優化問題的函數以及初值。後面的那些參數我們也很容易理解。如果您能用到，請自己研究。下面研究一個最簡單的問題，來感受這個函數的使用方法：f(x)=x**2-4*x+8，我們知道，這個函數的最小值是4，在x=2的時候取到。from scipy.optimize import fmin #引入優化包def myfunc(x):return x**2-4*x+8 #定義函數x0 = [1.3] #猜一個初值xopt = fmin(myfunc, x0) #求解print xopt #列印結果運行之後，給出的結果是：Optimization terminated successfully.Current function value: 4.000000Iterations: 16Function evaluations: 32[ 2.00001953]程序准確的計算得出了最小值，不過最小值點並不是嚴格的2，這應該是由二進制機器編碼誤差造成的。除了fmin_ncg必須提供梯度信息外，其他幾個函數的調用大同小異，完全類似。我們不妨做一個對比：from scipy.optimize import fmin,fmin_powell,fmin_bfgs,fmin_cgdef myfunc(x):return x**2-4*x+8x0 = [1.3]xopt1 = fmin(myfunc, x0)print xopt1printxopt2 = fmin_powell(myfunc, x0)print xopt2printxopt3 = fmin_bfgs(myfunc, x0)print xopt3printxopt4 = fmin_cg(myfunc,x0)print xopt4給出的結果是：Optimization terminated successfully.Current function value: 4.000000Iterations: 16Function evaluations: 32[ 2.00001953]Optimization terminated successfully.Current function value: 4.000000Iterations: 2Function evaluations: 531.99999999997Optimization terminated successfully.Current function value: 4.000000Iterations: 2Function evaluations: 12Gradient evaluations: 4[ 2.00000001]Optimization terminated successfully.Current function value: 4.000000Iterations: 2Function evaluations: 15Gradient evaluations: 5[ 2.]我們可以根據給出的消息直觀的判斷演算法的執行情況。每一種演算法數學上的問題，請自己看書學習。個人感覺，如果不是純研究數學的工作，沒必要搞清楚那些推導以及定理雲雲。不過，必須了解每一種演算法的優劣以及能力所及。在使用的時候，不妨多種演算法都使用一下，看看效果分別如何，同時，還可以互相印證演算法失效的問題。在from scipy.optimize import fmin之後，就可以使用help(fmin)來查看fmin的幫助信息了。幫助信息中沒有例子，但是給出了每一個參數的含義說明，這是調用函數時候的最有價值參考。有源碼研究癖好的，或者當你需要改進這些已經實現的演算法的時候，可能需要查看optimize中的每種演算法的源代碼。在這里：https:/ / github. com/scipy/scipy/blob/master/scipy/optimize/optimize.py聰明的你肯定發現了，順著這個鏈接往上一級、再往上一級，你會找到scipy的幾乎所有源碼！

⑷ python常用包及主要功能

Python常用包：NumPy數值計算、pandas數據處理、matplotlib數據可視化、sciPy科學計算、Scrapy爬蟲、scikit-learn機器學習、Keras深度學習、statsmodels統計建模計量經濟。
NumPy是使用Python進行科學計算的基礎包，Numpy可以提供數組支持以及相應的高效處理函數，是Python數據分析的基礎，也是SciPy、Pandas等數據處理和科學計算庫最基本的函數功能庫，且其數據類型對Python數據分析十分有用。
pandas 是python的一個數據分析包,是基於NumPy 的一種工具，該工具是為了解決數據分析任務而創建的。pandas提供了大量能使我們快速便捷地處理數據的函數和方法。
Matplotlib是強大的數據可視化工具和作圖庫，是主要用於繪制數據圖表的Python庫，提供了繪制各類可視化圖形的命令字型檔、簡單的介面，可以方便用戶輕松掌握圖形的格式，繪制各類可視化圖形。
SciPy是一組專門解決科學計算中各種標准問題域的包的集合，包含的功能有最優化、線性代數、積分、插值、擬合、特殊函數、快速傅里葉變換、信號處理和圖像處理、常微分方程求解和其他科學與工程中常用的計算等，這些對數據分析和挖掘十分有用。
Scrapy是專門為爬蟲而生的工具，具有URL讀取、HTML解析、存儲數據等功能，可以使用Twisted非同步網路庫來處理網路通訊，架構清晰，且包含了各種中間件介面，可以靈活地完成各種需求。
Scikit-Learn是Python常用的機器學習工具包，提供了完善的機器學習工具箱，支持數據預處理、分類、回歸、聚類、預測和模型分析等強大機器學習庫，其依賴於Numpy、Scipy和Matplotlib等。
Keras是深度學習庫，人工神經網路和深度學習模型，基於Theano之上，依賴於Numpy和Scipy，利用它可以搭建普通的神經網路和各種深度學習模型，如語言處理、圖像識別、自編碼器、循環神經網路、遞歸審計網路、卷積神經網路等。
Statsmodels是Python的統計建模和計量經濟學工具包，包括一些描述統計、統計模型估計和推斷。

⑸ Python怎麼做最優化

最優化
為什麼要做最優化呢？因為在生活中，人們總是希望幸福值或其它達到一個極值，比如做生意時希望成本最小，收入最大，所以在很多商業情境中，都會遇到求極值的情況。
函數求根
這里「函數的根」也稱「方程的根」，或「函數的零點」。
先把我們需要的包載入進來。import numpy as npimport scipy as spimport scipy.optimize as optimport matplotlib.pyplot as plt%matplotlib inline
函數求根和最優化的關系？什麼時候函數是最小值或最大值？
兩個問題一起回答：最優化就是求函數的最小值或最大值，同時也是極值，在求一個函數最小值或最大值時，它所在的位置肯定是導數為 0 的位置，所以要求一個函數的極值，必然要先求導，使其為 0，所以函數求根就是為了得到最大值最小值。
scipy.optimize 有什麼方法可以求根？
可以用 scipy.optimize 中的 bisect 或 brentq 求根。f = lambda x: np.cos(x) - x # 定義一個匿名函數x = np.linspace(-5, 5, 1000) # 先生成 1000 個 xy = f(x) # 對應生成 1000 個 f(x)plt.plot(x, y); # 看一下這個函數長什麼樣子plt.axhline(0, color='k'); # 畫一根橫線，位置在 y=0

opt.bisect(f, -5, 5) # 求取函數的根0.7390851332155535plt.plot(x, y)plt.axhline(0, color='k')plt.scatter([_], [0], c='r', s=100); # 這里的 [_] 表示上一個 Cell 中的結果，這里是 x 軸上的位置，0 是 y 上的位置

求根有兩種方法，除了上面介紹的 bisect，還有 brentq，後者比前者快很多。%timeit opt.bisect(f, -5, 5)%timeit opt.brentq(f, -5, 5)10000 loops, best of 3: 157 s per loopThe slowest run took 11.65 times longer than the fastest. This could mean that an intermediate result is being cached.10000 loops, best of 3: 35.9 s per loop
函數求最小化
求最小值就是一個最優化問題。求最大值時只需對函數做一個轉換，比如加一個負號，或者取倒數，就可轉成求最小值問題。所以兩者是同一問題。
初始值對最優化的影響是什麼？
舉例來說，先定義個函數。f = lambda x: 1-np.sin(x)/xx = np.linspace(-20., 20., 1000)y = f(x)
當初始值為 3 值，使用 minimize 函數找到最小值。minimize 函數是在新版的 scipy 里，取代了以前的很多最優化函數，是個通用的介面，背後是很多方法在支撐。x0 = 3xmin = opt.minimize(f, x0).x # x0 是起始點，起始點最好離真正的最小值點不要太遠plt.plot(x, y)plt.scatter(x0, f(x0), marker='o', s=300); # 起始點畫出來，用圓圈表示plt.scatter(xmin, f(xmin), marker='v', s=300); # 最小值點畫出來，用三角表示plt.xlim(-20, 20);

初始值為 3 時，成功找到最小值。
現在來看看初始值為 10 時，找到的最小值點。x0 = 10xmin = opt.minimize(f, x0).xplt.plot(x, y)plt.scatter(x0, f(x0), marker='o', s=300)plt.scatter(xmin, f(xmin), marker='v', s=300)plt.xlim(-20, 20);

由上圖可見，當初始值為 10 時，函數找到的是局部最小值點，可見 minimize 的默認演算法對起始點的依賴性。
那麼怎麼才能不管初始值在哪個位置，都能找到全局最小值點呢？
如何找到全局最優點？
可以使用 basinhopping 函數找到全局最優點，相關背後演算法，可以看幫助文件，有提供論文的索引和出處。
我們設初始值為 10 看是否能找到全局最小值點。x0 = 10from scipy.optimize import basinhoppingxmin = basinhopping(f,x0,stepsize = 5).xplt.plot(x, y);plt.scatter(x0, f(x0), marker='o', s=300);plt.scatter(xmin, f(xmin), marker='v', s=300);plt.xlim(-20, 20);

當起始點在比較遠的位置，依然成功找到了全局最小值點。
如何求多元函數最小值？
以二元函數為例，使用 minimize 求對應的最小值。def g(X): x,y = X return (x-1)**4 + 5 * (y-1)**2 - 2*x*yX_opt = opt.minimize(g, (8, 3)).x # (8,3) 是起始點print X_opt[ 1.88292611 1.37658521]fig, ax = plt.subplots(figsize=(6, 4)) # 定義畫布和圖形x_ = y_ = np.linspace(-1, 4, 100)X, Y = np.meshgrid(x_, y_)c = ax.contour(X, Y, g((X, Y)), 50) # 等高線圖ax.plot(X_opt[0], X_opt[1], 'r*', markersize=15) # 最小點的位置是個元組ax.set_xlabel(r"$x_1$", fontsize=18)ax.set_ylabel(r"$x_2$", fontsize=18)plt.colorbar(c, ax=ax) # colorbar 表示顏色越深，高度越高fig.tight_layout()

畫3D 圖。from mpl_toolkits.mplot3d import Axes3Dfrom matplotlib import cmfig = plt.figure()ax = fig.gca(projection='3d')x_ = y_ = np.linspace(-1, 4, 100)X, Y = np.meshgrid(x_, y_)surf = ax.plot_surface(X, Y, g((X,Y)), rstride=1, cstride=1, cmap=cm.coolwarm, linewidth=0, antialiased=False)cset = ax.contour(X, Y, g((X,Y)), zdir='z',offset=-5, cmap=cm.coolwarm)fig.colorbar(surf, shrink=0.5, aspect=5);

曲線擬合
曲線擬合和最優化有什麼關系？
曲線擬合的問題是，給定一組數據，它可能是沿著一條線散布的，這時要找到一條最優的曲線來擬合這些數據，也就是要找到最好的線來代表這些點，這里的最優是指這些點和線之間的距離是最小的，這就是為什麼要用最優化問題來解決曲線擬合問題。
舉例說明，給一些點，找到一條線，來擬合這些點。
先給定一些點：N = 50 # 點的個數m_true = 2 # 斜率b_true = -1 # 截距dy = 2.0 # 誤差np.random.seed(0)xdata = 10 * np.random.random(N) # 50 個 x，服從均勻分布ydata = np.random.normal(b_true + m_true * xdata, dy) # dy 是標准差plt.errorbar(xdata, ydata, dy, fmt='.k', ecolor='lightgray');

上面的點整體上呈現一個線性關系，要找到一條斜線來代表這些點，這就是經典的一元線性回歸。目標就是找到最好的線，使點和線的距離最短。要優化的函數是點和線之間的距離，使其最小。點是確定的，而線是可變的，線是由參數值，斜率和截距決定的，這里就是要通過優化距離找到最優的斜率和截距。
點和線的距離定義如下：def chi2(theta, x, y): return np.sum(((y - theta[0] - theta[1] * x)) ** 2)
上式就是誤差平方和。
誤差平方和是什麼？有什麼作用？
誤差平方和公式為：
誤差平方和大，表示真實的點和預測的線之間距離太遠，說明擬合得不好，最好的線，應該是使誤差平方和最小，即最優的擬合線，這里是條直線。
誤差平方和就是要最小化的目標函數。
找到最優的函數，即斜率和截距。theta_guess = [0, 1] # 初始值theta_best = opt.minimize(chi2, theta_guess, args=(xdata, ydata)).xprint(theta_best)[-1.01442005 1.93854656]
上面兩個輸出即是預測的直線斜率和截距，我們是根據點來反推直線的斜率和截距，那麼真實的斜率和截距是多少呢？-1 和 2，很接近了，差的一點是因為有噪音的引入。xfit = np.linspace(0, 10)yfit = theta_best[0] + theta_best[1] * xfitplt.errorbar(xdata, ydata, dy, fmt='.k', ecolor='lightgray');plt.plot(xfit, yfit, '-k');

最小二乘（Least Square）是什麼？
上面用的是 minimize 方法，這個問題的目標函數是誤差平方和，這就又有一個特定的解法，即最小二乘。
最小二乘的思想就是要使得觀測點和估計點的距離的平方和達到最小，這里的「二乘」指的是用平方來度量觀測點與估計點的遠近（在古漢語中「平方」稱為「二乘」），「最小」指的是參數的估計值要保證各個觀測點與估計點的距離的平方和達到最小。
關於最小二乘估計的計算，涉及更多的數學知識，這里不想詳述，其一般的過程是用目標函數對各參數求偏導數，並令其等於 0，得到一個線性方程組。具體推導過程可參考斯坦福機器學習講義 第 7 頁。def deviations(theta, x, y): return (y - theta[0] - theta[1] * x)theta_best, ier = opt.leastsq(deviations, theta_guess, args=(xdata, ydata))print(theta_best)[-1.01442016 1.93854659]
最小二乘 leastsq 的結果跟 minimize 結果一樣。注意 leastsq 的第一個參數不再是誤差平方和 chi2，而是誤差本身 deviations，即沒有平方，也沒有和。yfit = theta_best[0] + theta_best[1] * xfitplt.errorbar(xdata, ydata, dy, fmt='.k', ecolor='lightgray');plt.plot(xfit, yfit, '-k');

非線性最小二乘
上面是給一些點，擬合一條直線，擬合一條曲線也是一樣的。def f(x, beta0, beta1, beta2): # 首先定義一個非線性函數，有 3 個參數 return beta0 + beta1 * np.exp(-beta2 * x**2)beta = (0.25, 0.75, 0.5) # 先猜 3 個 betaxdata = np.linspace(0, 5, 50)y = f(xdata, *beta)ydata = y + 0.05 * np.random.randn(len(xdata)) # 給 y 加噪音def g(beta): return ydata - f(xdata, *beta) # 真實 y 和 預測值的差，求最優曲線時要用到beta_start = (1, 1, 1)beta_opt, beta_cov = opt.leastsq(g, beta_start)print beta_opt # 求到的 3 個最優的 beta 值[ 0.25525709 0.74270226 0.54966466]
拿估計的 beta_opt 值跟真實的 beta = (0.25, 0.75, 0.5) 值比較，差不多。fig, ax = plt.subplots()ax.scatter(xdata, ydata) # 畫點ax.plot(xdata, y, 'r', lw=2) # 真實值的線ax.plot(xdata, f(xdata, *beta_opt), 'b', lw=2) # 擬合的線ax.set_xlim(0, 5)ax.set_xlabel(r"$x$", fontsize=18)ax.set_ylabel(r"$f(x, \beta)$", fontsize=18)fig.tight_layout()

除了使用最小二乘，還可以使用曲線擬合的方法，得到的結果是一樣的。beta_opt, beta_cov = opt.curve_fit(f, xdata, ydata)print beta_opt[ 0.25525709 0.74270226 0.54966466]
有約束的最小化
有約束的最小化是指，要求函數最小化之外，還要滿足約束條件，舉例說明。
邊界約束def f(X): x, y = X return (x-1)**2 + (y-1)**2 # 這是一個碗狀的函數x_opt = opt.minimize(f, (0, 0), method='BFGS').x # 無約束最優化
假設有約束條件，x 和 y 要在一定的范圍內，如 x 在 2 到 3 之間，y 在 0 和 2 之間。bnd_x1, bnd_x2 = (2, 3), (0, 2) # 對自變數的約束x_cons_opt = opt.minimize(f, np.array([0, 0]), method='L-BFGS-B', bounds=[bnd_x1, bnd_x2]).x # bounds 矩形約束fig, ax = plt.subplots(figsize=(6, 4))x_ = y_ = np.linspace(-1, 3, 100)X, Y = np.meshgrid(x_, y_)c = ax.contour(X, Y, f((X,Y)), 50)ax.plot(x_opt[0], x_opt[1], 'b*', markersize=15) # 沒有約束下的最小值，藍色五角星ax.plot(x_cons_opt[0], x_cons_opt[1], 'r*', markersize=15) # 有約束下的最小值，紅色星星bound_rect = plt.Rectangle((bnd_x1[0], bnd_x2[0]), bnd_x1[1] - bnd_x1[0], bnd_x2[1] - bnd_x2[0], facecolor="grey")ax.add_patch(bound_rect)ax.set_xlabel(r"$x_1$", fontsize=18)ax.set_ylabel(r"$x_2$", fontsize=18)plt.colorbar(c, ax=ax)fig.tight_layout()

不等式約束
介紹下相關理論，先來看下存在等式約束的極值問題求法，比如下面的優化問題。
目標函數是 f(w)，下面是等式約束，通常解法是引入拉格朗日運算元，這里使用 ββ 來表示運算元，得到拉格朗日公式為
l 是等式約束的個數。
然後分別對 w 和ββ 求偏導，使得偏導數等於 0，然後解出 w 和βiβi，至於為什麼引入拉格朗日運算元可以求出極值，原因是 f(w) 的 dw 變化方向受其他不等式的約束，dw的變化方向與f(w)的梯度垂直時才能獲得極值，而且在極值處，f(w) 的梯度與其他等式梯度的線性組合平行，因此他們之間存在線性關系。（參考《最優化與KKT條件》）
對於不等式約束的極值問題
常常利用拉格朗日對偶性將原始問題轉換為對偶問題，通過解對偶問題而得到原始問題的解。該方法應用在許多統計學習方法中。有興趣的可以參閱相關資料，這里不再贅述。def f(X): return (X[0] - 1)**2 + (X[1] - 1)**2def g(X): return X[1] - 1.75 - (X[0] - 0.75)**4x_opt = opt.minimize(f, (0, 0), method='BFGS').xconstraints = [dict(type='ineq', fun=g)] # 約束採用字典定義，約束方式為不等式約束，邊界用 g 表示x_cons_opt = opt.minimize(f, (0, 0), method='SLSQP', constraints=constraints).xfig, ax = plt.subplots(figsize=(6, 4))x_ = y_ = np.linspace(-1, 3, 100)X, Y = np.meshgrid(x_, y_)c = ax.contour(X, Y, f((X, Y)), 50)ax.plot(x_opt[0], x_opt[1], 'b*', markersize=15) # 藍色星星，沒有約束下的最小值ax.plot(x_, 1.75 + (x_-0.75)**4, '', markersize=15)ax.fill_between(x_, 1.75 + (x_-0.75)**4, 3, color="grey")ax.plot(x_cons_opt[0], x_cons_opt[1], 'r*', markersize=15) # 在區域約束下的最小值ax.set_ylim(-1, 3)ax.set_xlabel(r"$x_0$", fontsize=18)ax.set_ylabel(r"$x_1$", fontsize=18)plt.colorbar(c, ax=ax)fig.tight_layout()

scipy.optimize.minimize 中包括了多種最優化演算法，每種演算法使用范圍不同，詳細參考官方文檔。

⑹ 如何提高python的運行效率

竅門一：關鍵代碼使用外部功能包

Python簡化了許多編程任務，但是對於一些時間敏感的任務，它的表現經常不盡人意。使用C/C++或機器語言的外部功能包處理時間敏感任務，可以有效提高應用的運行效率。這些功能包往往依附於特定的平台，因此你要根據自己所用的平台選擇合適的功能包。簡而言之，這個竅門要你犧牲應用的可移植性以換取只有通過對底層主機的直接編程才能獲得的運行效率。以下是一些你可以選擇用來提升效率的功能包：

Cython
Pylnlne
PyPy
Pyrex

這些功能包的用處各有不同。比如說，使用C語言的數據類型，可以使涉及內存操作的任務更高效或者更直觀。Pyrex就能幫助Python延展出這樣的功能。Pylnline能使你在Python應用中直接使用C代碼。內聯代碼是獨立編譯的，但是它把所有編譯文件都保存在某處，並能充分利用C語言提供的高效率。

竅門二：在排序時使用鍵

Python含有許多古老的排序規則，這些規則在你創建定製的排序方法時會佔用很多時間，而這些排序方法運行時也會拖延程序實際的運行速度。最佳的排序方法其實是盡可能多地使用鍵和內置的sort()方法。譬如，拿下面的代碼來說：

import operator
somelist = [(1, 5,]
在每段例子里，list都是根據你選擇的用作關鍵參數的索引進行排序的。這個方法不僅對數值類型有效，還同樣適用於字元串類型。

竅門三：針對循環的優化

每一種編程語言都強調最優化的循環方案。當使用Python時，你可以藉助豐富的技巧讓循環程序跑得更快。然而，開發者們經常遺忘的一個技巧是：盡量避免在循環中訪問變數的屬性。譬如，拿下面的代碼來說：

lowerlist = ['this', 'is', 'lowercase']
upper = str.upper
upperlist = []
append = upperlist.append
for word in lowerlist:
append(upper(word))
print(upperlist)
#Output = ['THIS', 'IS', 'LOWERCASE']
每次你調用str.upper, Python都會計算這個式子的值。然而，如果你把這個求值賦值給一個變數，那麼求值的結果就能提前知道，Python程序就能運行得更快。因此，關鍵就是盡可能減小Python在循環中的工作量。因為Python解釋執行的特性，在上面的例子中會大大減慢它的速度。

（注意：優化循環的方法還有很多，這只是其中之一。比如，很多程序員會認為，列表推導式是提高循環速度的最佳方法。關鍵在於，優化循環方案是提高應用程序運行速度的上佳選擇。）

竅門四：使用較新的Python版本

如果你在網上搜索Python，你會發現數不盡的信息都是關於如何升級Python版本。通常，每個版本的Python都會包含優化內容，使其運行速度優於之前的版本。但是，限制因素在於，你最喜歡的函數庫有沒有同步更新支持新的Python版本。與其爭論函數庫是否應該更新，關鍵在於新的Python版本是否足夠高效來支持這一更新。

你要保證自己的代碼在新版本里還能運行。你需要使用新的函數庫才能體驗新的Python版本，然後你需要在做出關鍵性的改動時檢查自己的應用。只有當你完成必要的修正之後，你才能體會新版本的不同。

然而，如果你只是確保自己的應用在新版本中可以運行，你很可能會錯過新版本提供的新特性。一旦你決定更新，請分析你的應用在新版本下的表現，並檢查可能出問題的部分，然後優先針對這些部分應用新版本的特性。只有這樣，用戶才能在更新之初就覺察到應用性能的改觀。

竅門五：嘗試多種編碼方法

每次創建應用時都使用同一種編碼方法幾乎無一例外會導致應用的運行效率不盡人意。可以在程序分析時嘗試一些試驗性的辦法。譬如說，在處理字典中的數據項時，你既可以使用安全的方法，先確保數據項已經存在再進行更新，也可以直接對數據項進行更新，把不存在的數據項作為特例分開處理。請看下面第一段代碼：

n = 16
myDict = {}
for i in range(0, n):
char = 'abcd'[i%4]
if char not in myDict:
myDict[char] = 0
myDict[char] += 1
print(myDict)
當一開始myDict為空時，這段代碼會跑得比較快。然而，通常情況下，myDict填滿了數據，至少填有大部分數據，這時換另一種方法會更有效率。

n = 16
myDict = {}
for i in range(0, n):
char = 'abcd'[i%4]
try:
myDict[char] += 1
except KeyError:
myDict[char] = 1
print(myDict)
在兩種方法中輸出結果都是一樣的。區別在於輸出是如何獲得的。跳出常規的思維模式，創建新的編程技巧能使你的應用更有效率。

竅門六：交叉編譯你的應用

開發者有時會忘記計算機其實並不理解用來創建現代應用程序的編程語言。計算機理解的是機器語言。為了運行你的應用，你藉助一個應用將你所編的人類可讀的代碼轉換成機器可讀的代碼。有時，你用一種諸如Python這樣的語言編寫應用，再以C++這樣的語言運行你的應用，這在運行的角度來說，是可行的。關鍵在於，你想你的應用完成什麼事情，而你的主機系統能提供什麼樣的資源。

Nuitka是一款有趣的交叉編譯器，能將你的Python代碼轉化成C++代碼。這樣，你就可以在native模式下執行自己的應用，而無需依賴於解釋器程序。你會發現自己的應用運行效率有了較大的提高，但是這會因平台和任務的差異而有所不同。

（注意：Nuitka現在還處在測試階段，所以在實際應用中請多加註意。實際上，當下最好還是把它用於實驗。此外，關於交叉編譯是否為提高運行效率的最佳方法還存在討論的空間。開發者已經使用交叉編譯多年，用來提高應用的速度。記住，每一種解決辦法都有利有弊，在把它用於生產環境之前請仔細權衡。）

在使用交叉編譯器時，記得確保它支持你所用的Python版本。Nuitka支持Python2.6, 2.7, 3.2和3.3。為了讓解決方案生效，你需要一個Python解釋器和一個C++編譯器。Nuitka支持許多C++編譯器，其中包括Microsoft Visual Studio,MinGW 和 Clang/LLVM。

交叉編譯可能造成一些嚴重問題。比如，在使用Nuitka時，你會發現即便是一個小程序也會消耗巨大的驅動空間。因為Nuitka藉助一系列的動態鏈接庫（DDLs）來執行Python的功能。因此，如果你用的是一個資源很有限的系統，這種方法或許不太可行。

⑺ 學習多目標優化需要掌握哪些python知識

多目標優化

目標優化問題一般地就是指通過一定的優化演算法獲得目標函數的最優化解。當優化的目標函數為一個時稱之為單目標優化(Single-
objective Optimization Problem,
SOP)。當優化的目標函數有兩個或兩個以上時稱為多目標優化(Multi-objective Optimization Problem,
MOP)。不同於單目標優化的解為有限解，多目標優化的解通常是一組均衡解。

多目標優化演算法歸結起來有傳統優化演算法和智能優化演算法兩大類。
1. 傳統優化演算法包括加權法、約束法和線性規劃法等，實質上就是將多目標函數轉化為單目標函數，通過採用單目標優化的方法達到對多目標函數的求解。
2. 智能優化演算法包括進化演算法（Evolutionary Algorithm, 簡稱EA）、粒子群演算法（Particle Swarm Optimization, PSO）等。

Pareto最優解：

若x*∈C*,且在C中不存在比x更優越的解x，則稱x*是多目標最優化模型式的Pareto最優解，又稱為有效解。
一般來說，多目標優化問題並不存在一個最優解，所有可能的解都稱為非劣解，也稱為Pareto解。傳統優化技術一般每次能得到Pareo解集中的一個，而
用智能演算法來求解，可以得到更多的Pareto解，這些解構成了一個最優解集，稱為Pareto最優解。它是由那些任一個目標函數值的提高都必須以犧牲其
他目標函數值為代價的解組成的集合,稱為Pareto最優域，簡稱Pareto集。

Pareto有效(最優)解非劣解集是指由這樣一些解組成的集合：與集合之外的任何解相比它們至少有一個目標函數比集合之外的解好。

求解多目標優化問題最有名的就是NSGA-II了，是多目標遺傳演算法，但其對解的選擇過程可以用在其他優化演算法上，例如粒子群，蜂群等等。這里簡單介紹一下NSGA-II的選擇演算法。主要包含三個部分：
1. 快速非支配排序
要先講一下支配的概念，對於解X1和X2，如果X1對應的所有目標函數都不比X2大（最小問題），且存在一個目標值比X2小，則X2被X1支配。
快速非支配排序是一個循環分級過程：首先找出群體中的非支配解集，記為第一非支配層，irank=1（irank是個體i的非支配值），將其從群體中除去，繼續尋找群體中的非支配解集，然後irank=2。
2. 個體擁擠距離
為了使計算結果在目標空間比較均勻的分布，維持種群多樣性，對每個個體計算擁擠距離，選擇擁擠距離大的個體，擁擠距離的定義為：
L[i]d=L[i]d+(L[i+1]m−L[i−1]m)/(fmaxm−fminm)
L[i+1]m是第i+1個個體的第m目標函數值，fmaxm 和 fminm是集合中第m個目標函數的最大和最小值。
3. 精英策略選擇
精英策略就是保留父代中的優良個體直接進入子代，防止獲得的Pareto最優解丟失。將第t次產生的子代種群和父代種群合並，然後對合並後的新種群進行非支配排序，然後按照非支配順序添加到規模為N的種群中作為新的父代。

⑻ python找一組5個參數數據的最優化組合

dt=[{"ip","sh","li"},{"qw","ty","ko"}] c.extend([i for i in dt if 'ip' in i or 'qw' in i])

Python 3.5.2 (default, Dec 7 2016, 23:38:49)
[GCC 4.4.7 20120313 (Red Hat 4.4.7-17)] on linux
Type "help", "right", "credits" or "license" for more information.
>>> dt=[{"ip","sh","li"},{"qw","ty","ko"}]
>>> c=[]
>>> c.extend([i for i in dt if 'ip' in i or 'qw' in i])
>>> c
[{'li', 'sh', 'ip'}, {'ko', 'qw', 'ty'}]

⑼ 如何優化python 機器學習庫中的函數

def do_POST(self):
mpath,margs=urllib.splitquery(self.path)
datas = self.rfile.read(int(self.headers['content-length']))
self.do_action(mpath, datas)

def do_action(self, path, args):
self.outputtxt(path + args )

def outputtxt(self, content):
#指定返回編碼
enc = "UTF-8"
content = content.encode(enc)
f = io.BytesIO()
f.write(content)
f.seek(0)
self.send_response(200)
self.send_header("Content-type", "text/html; charset=%s" % enc)
self.send_header("Content-Length", str(len(content)))
self.end_headers()
shutil.fileobj(f,self.wfile)

⑽ 如何用python實現Markowitz投資組合優化

0.導入需要的包import pandas as pd
import numpy as np
import statsmodels.api as sm #統計運算
import scipy.stats as scs #科學計算
import matplotlib.pyplot as plt #繪圖

1.選取幾只感興趣的股票
000413 東旭光電，000063 中興通訊，002007 華蘭生物，000001 平安銀行，000002 萬科A
並比較一下數據（2015-01-01至2015-12-31）
In[1]:
stock_set = ['000413.XSHE','000063.XSHE','002007.XSHE','000001.XSHE','000002.XSHE']
noa = len(stock_set)
df = get_price(stock_set, start_date = '2015-01-01', end_date ='2015-12-31', 'daily', ['close'])
data = df['close']
#規范化後時序數據
(data/data.ix[0]*100).plot(figsize = (8,5))
Out[1]:

2.計算不同證券的均值、協方差
每年252個交易日，用每日收益得到年化收益。計算投資資產的協方差是構建資產組合過程的核心部分。運用pandas內置方法生產協方差矩陣。
In [2]:
returns = np.log(data / data.shift(1))
returns.mean()*252
Out[2]:

000413.XSHE 0.184516
000063.XSHE 0.176790
002007.XSHE 0.309077
000001.XSHE -0.102059
000002.XSHE 0.547441

In [3]:
returns.cov()*252
Out[3]:

3.給不同資產隨機分配初始權重
由於A股不允許建立空頭頭寸，所有的權重系數均在0-1之間
In [4]:
weights = np.random.random(noa)
weights /= np.sum(weights)
weights
Out[4]:

array([ 0.37505798, 0.21652754, 0.31590981, 0.06087709, 0.03162758])

4.計算預期組合年化收益、組合方差和組合標准差
In [5]:
np.sum(returns.mean()*weights)*252
Out[5]:

0.21622558669017816

In [6]:
np.dot(weights.T, np.dot(returns.cov()*252,weights))
Out[6]:

0.23595133640121463

In [7]:
np.sqrt(np.dot(weights.T, np.dot(returns.cov()* 252,weights)))
Out[7]:

0.4857482232609962

5.用蒙特卡洛模擬產生大量隨機組合
進行到此，我們最想知道的是給定的一個股票池（證券組合）如何找到風險和收益平衡的位置。
下面通過一次蒙特卡洛模擬，產生大量隨機的權重向量，並記錄隨機組合的預期收益和方差。
In [8]:
port_returns = []
port_variance = []
for p in range(4000):
weights = np.random.random(noa)
weights /=np.sum(weights)
port_returns.append(np.sum(returns.mean()*252*weights))
port_variance.append(np.sqrt(np.dot(weights.T, np.dot(returns.cov()*252, weights))))
port_returns = np.array(port_returns)
port_variance = np.array(port_variance)
#無風險利率設定為4%
risk_free = 0.04
plt.figure(figsize = (8,4))
plt.scatter(port_variance, port_returns, c=(port_returns-risk_free)/port_variance, marker = 'o')
plt.grid(True)
plt.xlabel('excepted volatility')
plt.ylabel('expected return')
plt.colorbar(label = 'Sharpe ratio')
Out[8]:

6.投資組合優化1——sharpe最大
建立statistics函數來記錄重要的投資組合統計數據（收益，方差和夏普比）
通過對約束最優問題的求解，得到最優解。其中約束是權重總和為1。
In [9]:
def statistics(weights):
weights = np.array(weights)
port_returns = np.sum(returns.mean()*weights)*252
port_variance = np.sqrt(np.dot(weights.T, np.dot(returns.cov()*252,weights)))
return np.array([port_returns, port_variance, port_returns/port_variance])
#最優化投資組合的推導是一個約束最優化問題
import scipy.optimize as sco
#最小化夏普指數的負值
def min_sharpe(weights):
return -statistics(weights)[2]
#約束是所有參數(權重)的總和為1。這可以用minimize函數的約定表達如下
cons = ({'type':'eq', 'fun':lambda x: np.sum(x)-1})
#我們還將參數值(權重)限制在0和1之間。這些值以多個元組組成的一個元組形式提供給最小化函數
bnds = tuple((0,1) for x in range(noa))
#優化函數調用中忽略的唯一輸入是起始參數列表(對權重的初始猜測)。我們簡單的使用平均分布。
opts = sco.minimize(min_sharpe, noa*[1./noa,], method = 'SLSQP', bounds = bnds, constraints = cons)
opts
Out[9]:
status: 0
success: True
njev: 4
nfev: 28
fun: -1.1623048291871221
x: array([ -3.60840218e-16, 2.24626781e-16, 1.63619563e-01, -2.27085639e-16, 8.36380437e-01])
message: 'Optimization terminated successfully.'
jac: array([ 1.81575805e-01, 5.40387481e-01, 8.18073750e-05, 1.03137662e+00, -1.60038471e-05, 0.00000000e+00])
nit: 4

得到的最優組合權重向量為：
In [10]:
opts['x'].round(3)
Out[10]:
array([-0. , 0. , 0.164, -0. , 0.836])

sharpe最大的組合3個統計數據分別為：
In [11]:
#預期收益率、預期波動率、最優夏普指數
statistics(opts['x']).round(3)
Out[11]:

array([ 0.508, 0.437, 1.162])

7.投資組合優化2——方差最小
接下來，我們通過方差最小來選出最優投資組合。
In [12]:
#但是我們定義一個函數對 方差進行最小化
def min_variance(weights):
return statistics(weights)[1]
optv = sco.minimize(min_variance, noa*[1./noa,],method = 'SLSQP', bounds = bnds, constraints = cons)
optv
Out[12]:
status: 0
success: True
njev: 7
nfev: 50
fun: 0.38542969450547221
x: array([ 1.14787640e-01, 3.28089742e-17, 2.09584008e-01, 3.53487044e-01, 3.22141307e-01])
message: 'Optimization terminated successfully.'
jac: array([ 0.3851725 , 0.43591119, 0.3861807 , 0.3849672 , 0.38553924, 0. ])
nit: 7

方差最小的最優組合權重向量及組合的統計數據分別為：
In [13]:
optv['x'].round(3)
Out[13]:
array([ 0.115, 0. , 0.21 , 0.353, 0.322])

In [14]:
#得到的預期收益率、波動率和夏普指數
statistics(optv['x']).round(3)
Out[14]:
array([ 0.226, 0.385, 0.587])

8.組合的有效前沿
有效前沿有既定的目標收益率下方差最小的投資組合構成。
在最優化時採用兩個約束，1.給定目標收益率，2.投資組合權重和為1。
In [15]:
def min_variance(weights):
return statistics(weights)[1]
#在不同目標收益率水平（target_returns）循環時，最小化的一個約束條件會變化。
target_returns = np.linspace(0.0,0.5,50)
target_variance = []
for tar in target_returns:
cons = ({'type':'eq','fun':lambda x:statistics(x)[0]-tar},{'type':'eq','fun':lambda x:np.sum(x)-1})
res = sco.minimize(min_variance, noa*[1./noa,],method = 'SLSQP', bounds = bnds, constraints = cons)
target_variance.append(res['fun'])
target_variance = np.array(target_variance)

下面是最優化結果的展示。
叉號：構成的曲線是有效前沿（目標收益率下最優的投資組合）
紅星：sharpe最大的投資組合
黃星：方差最小的投資組合
In [16]:
plt.figure(figsize = (8,4))
#圓圈：蒙特卡洛隨機產生的組合分布
plt.scatter(port_variance, port_returns, c = port_returns/port_variance,marker = 'o')
#叉號：有效前沿
plt.scatter(target_variance,target_returns, c = target_returns/target_variance, marker = 'x')
#紅星：標記最高sharpe組合
plt.plot(statistics(opts['x'])[1], statistics(opts['x'])[0], 'r*', markersize = 15.0)
#黃星：標記最小方差組合
plt.plot(statistics(optv['x'])[1], statistics(optv['x'])[0], 'y*', markersize = 15.0)
plt.grid(True)
plt.xlabel('expected volatility')
plt.ylabel('expected return')
plt.colorbar(label = 'Sharpe ratio')