pythongradient

1. python使用matplotlib怎麼畫光滑曲線

matplotlib 是Python最著名的繪圖庫，它提供了一整套和matlab相似的命令API，十分適合互動式地進行制圖。而且也可以方便地將它作為繪圖控制項，嵌入GUI應用程序中。
它的文檔相當完備，並且 Gallery頁面 中有上百幅縮略圖，打開之後都有源程序。因此如果你需要繪制某種類型的圖，只需要在這個頁面中瀏覽/復制/粘貼一下，基本上都能搞定。

在Linux下比較著名的數據圖工具還有gnuplot，這個是免費的，Python有一個包可以調用gnuplot，但是語法比較不習慣，而且畫圖質量不高。
而 Matplotlib則比較強：Matlab的語法、python語言、latex的畫圖質量（還可以使用內嵌的latex引擎繪制的數學公式）。

快速繪圖
matplotlib的pyplot子庫提供了和matlab類似的繪圖API，方便用戶快速繪制2D圖表。例子：

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#
coding=gbk
'''
Created
on Jul 12,2014
python
科學計算學習：numpy快速處理數據測試
@author:
皮皮
'''
importstring
importmatplotlib.pyplot
as plt
importnumpy
as np

if__name__
== '__main__':
file
= open(E:machine_learningdatasetshousing_datahousing_data_ages.txt, 'r')
linesList
= file.readlines()
#
print(linesList)
linesList
= [line.strip().split(,) forline
in linesList]
file.close()
print(linesList:)
print(linesList)
#
years = [string.atof(x[0])forx
in linesList]
years
= [x[0]forx
in linesList]
print(years)
price
= [x[1]forx
in linesList]
print(price)
plt.plot(years,
price, 'b*')#,label=$cos(x^2)$)
plt.plot(years,
price, 'r')
plt.xlabel(years(+2000))
plt.ylabel(housing
average price(*2000yuan))
plt.ylim(0,15)
plt.title('line_regression
& gradient decrease')
plt.legend()
plt.show()

2. 如何用Python在10分鍾內建立一個預測模型

預測模型的分解過程
我總是集中於投入有質量的時間在建模的初始階段，比如，假設生成、頭腦風暴、討論或理解可能的結果范圍。所有這些活動都有助於我解決問題，並最終讓我設計出更強大的商業解決方案。為什麼你要在前面花費這段時間，這有充分的理由：
你有足夠的時間投入並且你是無經驗的（這是有影響的）
你不帶有其它數據觀點或想法的偏見（我總是建議，在深入研究數據之前做假設生成）
在後面的階段，你會急於完成該項目而沒有能力投入有質量的時間了。
這個階段需要投入高質量時間，因此我沒有提及時間表，不過我建議你把它作為標準的做法。這有助於你建立建立更好地預測模型，在後面的階段的只需較少的迭代工作。讓我們來看看建立第一個模型的剩餘階段的時間表：
數據描述性分析——50%的時間
數據預處理（缺失值和異常值修復）——40%的時間
數據建模——4%的時間
性能預測——6%的時間
讓我們一步一步完成每個過程（每一步投入預測的時間）：
階段1：描述性分析/數據探索
在我剛開始成為數據科學家的時候，數據探索占據了我大量的時間。不過，隨著時間的推移，我已經把大量的數據操作自動化了。由於數據准備占據建立第一個模型工作量的50%，自動化的好處是顯而易見的。
這是我們的第一個基準模型，我們去掉任何特徵設計。因此，描述分析所需的時間僅限於了解缺失值和直接可見的大的特徵。在我的方法體系中，你將需要2分鍾來完成這一步（假設，100000個觀測數據集）。
我的第一個模型執行的操作：
確定ID，輸入特徵和目標特徵
確定分類和數值特徵
識別缺失值所在列
階段2：數據預處理（缺失值處理）
有許多方法可以解決這個問題。對於我們的第一個模型，我們將專注於智能和快速技術來建立第一個有效模型。
為缺失值創建假標志：有用，有時缺失值本身就攜帶了大量的信息。
用均值、中位數或其它簡單方法填補缺失值：均值和中位數填補都表現良好，大多數人喜歡用均值填補但是在有偏分布的情況下我建議使用中位數。其它智能的方法與均值和中位數填補類似，使用其它相關特徵填補或建立模型。比如，在Titanic生存挑戰中，你可以使用乘客名字的稱呼，比如：「Mr.」, 「Miss.」,」Mrs.」,」Master」，來填補年齡的缺失值，這對模型性能有很好的影響。
填補缺失的分類變數：創建一個新的等級來填補分類變數，讓所有的缺失值編碼為一個單一值比如，「New_Cat」，或者，你可以看看頻率組合，使用高頻率的分類變數來填補缺失值。
由於數據處理方法如此簡單，你可以只需要3到4分鍾來處理數據。
階段3：數據建模
根據不同的業務問題，我推薦使用GBM或RandomForest技術的任意一種。這兩個技術可以極其有效地創建基準解決方案。我已經看到數據科學家通常把這兩個方法作為他們的第一個模型同時也作為最後一個模型。這最多用去4到5分鍾。
階段4：性能預測
有各種各樣的方法可以驗證你的模型性能，我建議你將訓練數據集劃分為訓練集和驗證集（理想的比例是70：30）並且在70%的訓練數據集上建模。現在，使用30%的驗證數據集進行交叉驗證並使用評價指標進行性能評估。最後需要1到2分鍾執行和記錄結果。
本文的目的不是贏得比賽，而是建立我們自己的基準。讓我們用python代碼來執行上面的步驟，建立你的第一個有較高影響的模型。
讓我們開始付諸行動
首先我假設你已經做了所有的假設生成並且你擅長使用python的基本數據科學操作。我用一個數據科學挑戰的例子來說明。讓我們看一下結構：
步驟1：導入所需的庫，讀取測試和訓練數據集。
#導入pandas、numpy包，導入LabelEncoder、random、RandomForestClassifier、GradientBoostingClassifier函數
import pandas as pd
import numpy as np
fromsklearn.preprocessing import LabelEncoder
import random
fromsklearn.ensemble import RandomForestClassifier
from sklearn.ensembleimport GradientBoostingClassifier
#讀取訓練、測試數據集
train=pd.read_csv('C:/Users/AnalyticsVidhya/Desktop/challenge/Train.csv')
test=pd.read_csv('C:/Users/AnalyticsVidhya/Desktop/challenge/Test.csv')
#創建訓練、測試數據集標志
train='Train'
test='Test'
fullData =pd.concat(,axis=0) #聯合訓練、測試數據集
步驟2：該框架的第二步並不需要用到python，繼續下一步。
步驟3：查看數據集的列名或概要
fullData.columns # 顯示所有的列名稱
fullData.head(10) #顯示數據框的前10條記錄
fullData.describe() #你可以使用describe()函數查看數值域的概要
步驟4：確定a)ID變數 b)目標變數 c)分類變數 d)數值變數 e)其他變數。
ID_col =
target_col =
cat_cols =
num_cols= list(set(list(fullData.columns))-set(cat_cols)-set(ID_col)-set(target_col)-set(data_col))
other_col= #為訓練、測試數據集設置標識符
步驟5：識別缺失值變數並創建標志
fullData.isnull().any()#返回True或False，True意味著有缺失值而False相反
num_cat_cols = num_cols+cat_cols # 組合數值變數和分類變數
#為有缺失值的變數創建一個新的變數
# 對缺失值標志為1，否則為0
for var in num_cat_cols:
if fullData.isnull().any()=True:
fullData=fullData.isnull()*1
步驟6：填補缺失值
#用均值填補數值缺失值
fullData = fullData.fillna(fullData.mean(),inplace=True)
#用-9999填補分類變數缺失值
fullData = fullData.fillna(value = -9999)
步驟7：創建分類變數的標簽編碼器，將數據集分割成訓練和測試集，進一步，將訓練數據集分割成訓練集和測試集。
#創建分類特徵的標簽編碼器
for var in cat_cols:
number = LabelEncoder()
fullData = number.fit_transform(fullData.astype('str'))
#目標變數也是分類變數，所以也用標簽編碼器轉換
fullData = number.fit_transform(fullData.astype('str'))
train=fullData='Train']
test=fullData='Test']
train = np.random.uniform(0, 1, len(train)) <= .75
Train, Validate = train=True], train=False]
步驟8：將填補和虛假（缺失值標志）變數傳遞到模型中，我使用隨機森林來預測類。
features=list(set(list(fullData.columns))-set(ID_col)-set(target_col)-set(other_col))
x_train = Train.values
y_train = Train.values
x_validate = Validate.values
y_validate = Validate.values
x_test=test.values
random.seed(100)
rf = RandomForestClassifier(n_estimators=1000)
rf.fit(x_train, y_train)
步驟9：檢查性能做出預測
status = rf.predict_proba(x_validate)
fpr, tpr, _ = roc_curve(y_validate, status)
roc_auc = auc(fpr, tpr)
print roc_auc
final_status = rf.predict_proba(x_test)
test=final_status
test.to_csv('C:/Users/Analytics Vidhya/Desktop/model_output.csv',columns=)
現在可以提交了！

3. 用Python寫過哪些的小工具

為了逃避學校布置的美術作業，寫過一個畫素描的程序。
從後再也不擔心美術作業了。
也就是利用Python的PIL庫來 將彩色圖片轉化為素描效果的圖片

更新說明：
前面那個程序寫的太粗糙了，不好意思拿出來分享，重新寫了一遍，加上了GUI圖形界面。
配置環境：
windows 10
python 3.5

image.py
from PIL import Image
import numpy as np
import os
import join
import time
def image(sta,end,depths=10):
a = np.asarray(Image.open(sta).convert('L')).astype('float')
depth = depths # (0-100)
grad = np.gradient(a) # 取圖像灰度的梯度值
grad_x, grad_y = grad # 分別取橫縱圖像梯度值
grad_x = grad_x * depth / 100.
grad_y = grad_y * depth / 100.
A = np.sqrt(grad_x ** 2 + grad_y ** 2 + 1.)
uni_x = grad_x / A
uni_y = grad_y / A
uni_z = 1. / A
vec_el = np.pi / 2.2 # 光源的俯視角度，弧度值
vec_az = np.pi / 4. # 光源的方位角度，弧度值
dx = np.cos(vec_el) * np.cos(vec_az) # 光源對x 軸的影響
dy = np.cos(vec_el) * np.sin(vec_az) # 光源對y 軸的影響
dz = np.sin(vec_el) # 光源對z 軸的影響
b = 255 * (dx * uni_x + dy * uni_y + dz * uni_z) # 光源歸一化
b = b.clip(0, 255)
im = Image.fromarray(b.astype('uint8')) # 重構圖像
im.save(end)

def mains(numbers):
number = int(numbers)
startss = os.listdir(".\輸入----圖片")
time.sleep(2)
for starts in startss:
start = ''.join(starts)
print('正在轉化--圖片： ' + start)
sta = './' + '輸入----圖片/' + start
end = './' + '輸出----圖片/' + 'HD_20' + start
image(sta=sta,end=end,depths=number)

簡單來說，就是利用python的Numpy庫，將圖像降維轉化為數字化的數據，之後對數據進行操作，再利用pillow庫將操作好的數據轉化為素描效果的圖片。
GUI圖形界面程序
main.py
import os
from image import mains
from tkinter import *

def exists_mkdir():
if os.path.exists('輸出----圖片') and os.path.exists('輸入----圖片'):
pass
else:
os.mkdir('輸出----圖片')
os.mkdir('輸入----圖片')

def images():
try:
s1 = e1.get()
a = mains(s1)
c["text"] = "我們的程序運行成功了"
except Exception:
c["text"] = "程序運行出錯了,可能是缺少了兩個配置文件"

#創建程序運行需要的工作目錄
exists_mkdir()

tk = Tk()
# 設置窗口大小和位置
tk.geometry('430x350+80+60')

# 不允許改變窗口大小
tk.resizable(False, False)

## 用來顯示Label組件
tk.title('素描圖生成器')
w1 = Label(tk,text='作者博客：www.liuchaoblog.live')
w = Label(tk,text='')
w2 = Label(tk,text='歡迎使用：')
w3 = Label(tk,text='步驟一：將需要轉化的圖片放入 輸入----圖片 文件夾下')
w4 = Label(tk,text='步驟二：輸入 0-100的數值，數值越大，顏色越深。--------標准參數是 10 ')
w5 = Label(tk,text='步驟三：點擊確認 運行程序 等待出現提示')
w6 = Label(tk,text='步驟四：到輸入----圖片 文件夾找到素描圖')
w1.grid(row=0,column=0,sticky=W)
w.grid(row=1,column=0,sticky=W)
w2.grid(row=2,column=0,sticky=W)
w3.grid(row=3,column=0,sticky=W)
w4.grid(row=4,column=0,sticky=W)
w5.grid(row=5,column=0,sticky=W)
w6.grid(row=6,column=0,sticky=W)

l = Label(tk,text="輸入 0-100的數值")
l.grid(row=8,column=0,sticky=E)

## 用來顯示輸入框
e1 = Entry(tk)
e1.grid(row=10,column=0,sticky=E)

## 用來顯示Button
b = Button(tk,text='確定',command=images)
b.grid(row=12,column=0,sticky=E)

c = Label(tk,text="",background="yellow")
c.grid(row = 15)

# 啟動消息主循環
tk.mainloop()

運行效果：

這個程序我用pyinstaller做成exe文件了。

4. 求python中圖片顏色過渡的程序!!!!!CS+英文高手請進!!!!!!!!

是不是翻譯？
翻譯：
必須被命名為myPic功能()

函數必須創造一個新的空畫和以下特點:

寬度必須256個像素

身高必須256個像素

背景必須就黑了

這幅畫必須儲存在變數稱為的照片

函數必須使用其是的顯示功能來顯示空的黑色的圖像(見下文)3待辦事項,

函數必須定義一個變數稱為blueVal,把它設置為零

函數必須使用循環改變每個像素的顏色在以下方式:

在循環的藍色RGB財產的像素必須儲存在blueVal價值

blueVal必須增加的過程中循環的每步迭代計算,直至達到256那時它必須被重置到零(提示:使用模操作符)

函數必須使用其是的粉刷最新的功能,以顯示圖像(見下文)4待辦事項,

功能分級的目的,myPic()以上所描述的被認為是由如下TODOs:

干3:功能myPic()建造一個空的黑色的圖像像素和256×256的顯示出來

待辦事項,4:功能myPic()產生,顯示了黑藍色的梯度充滿圖展示於本許可證圖1

5. 如何使用python計算常微分方程

常用形式
odeint(func, y0, t,args,Dfun)
一般這種形式就夠用了。
下面是官方的例子，求解的是
D(D(y1))-t*y1=0
為了方便，採取D=d/dt。如果我們令初值
y1(0) = 1.0/3**(2.0/3.0)/gamma(2.0/3.0)
D(y1)(0) = -1.0/3**(1.0/3.0)/gamma(1.0/3.0)
這個微分方程的解y1=airy(t)。

令D(y1)=y0，就有這個常微分方程組。
D(y0)=t*y1
D(y1)=y0

Python求解該微分方程。
>>> from scipy.integrate import odeint
>>> from scipy.special import gamma, airy
>>> y1_0 = 1.0/3**(2.0/3.0)/gamma(2.0/3.0)
>>> y0_0 = -1.0/3**(1.0/3.0)/gamma(1.0/3.0)
>>> y0 = [y0_0, y1_0]
>>> def func(y, t):
... return [t*y[1],y[0]]
>>> def gradient(y,t):
... return [[0,t],[1,0]]
>>> x = arange(0,4.0, 0.01)
>>> t = x
>>> ychk = airy(x)[0]
>>> y = odeint(func, y0, t)
>>> y2 = odeint(func, y0, t, Dfun=gradient)
>>> print ychk[:36:6]
[ 0.355028 0.339511 0.324068 0.308763 0.293658 0.278806]
>>> print y[:36:6,1]
[ 0.355028 0.339511 0.324067 0.308763 0.293658 0.278806]
>>> print y2[:36:6,1]
[ 0.355028 0.339511 0.324067 0.308763 0.293658 0.278806]

得到的解與精確值相比，誤差相當小。
=======================================================================================================

args是額外的參數。
用法請參看下面的例子。這是一個洛侖茲曲線的求解，並且用matplotlib繪出空間曲線圖。（來自《python科學計算》）
from scipy.integrate import odeint
import numpy as np
def lorenz(w, t, p, r, b):
# 給出位置矢量w，和三個參數p, r, b 計算出
# dx/dt, dy/dt, dz/dt 的值
x, y, z = w
# 直接與lorenz 的計算公式對應
return np.array([p*(y-x), x*(r-z)-y, x*y-b*z])
t = np.arange(0, 30, 0.01) # 創建時間點
# 調用ode 對lorenz 進行求解, 用兩個不同的初始值
track1 = odeint(lorenz, (0.0, 1.00, 0.0), t, args=(10.0, 28.0, 3.0))
track2 = odeint(lorenz, (0.0, 1.01, 0.0), t, args=(10.0, 28.0, 3.0))
# 繪圖
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
fig = plt.figure()
ax = Axes3D(fig)
ax.plot(track1[:,0], track1[:,1], track1[:,2])
ax.plot(track2[:,0], track2[:,1], track2[:,2])
plt.show()
===========================================================================
scipy.integrate.odeint(func, y0, t, args=(), Dfun=None, col_deriv=0, full_output=0, ml=None, mu=None, rtol=None, atol=None, tcrit=None, h0=0.0, hmax=0.0, hmin=0.0, ixpr=0, mxstep=0, mxhnil=0, mxordn=12, mxords=5, printmessg=0)
計算常微分方程（組）
使用 FORTRAN庫odepack中的lsoda解常微分方程。這個函數一般求解初值問題。

參數：

func : callable(y, t0, ...) 計算y在t0 處的導數。
y0 : 數組 y的初值條件（可以是矢量）
t : 數組 為求出y，這是一個時間點的序列。初值點應該是這個序列的第一個元素。
args : 元組 func的額外參數
Dfun : callable(y, t0, ...) 函數的梯度(Jacobian)。即雅可比多項式。
col_deriv : boolean. True，Dfun定義列向導數（更快），否則Dfun會定義橫排導數
full_output : boolean 可選輸出，如果為True 則返回一個字典，作為第二輸出。
printmessg : boolean 是否列印convergence 消息。

返回： y : array, shape (len(y0), len(t))
數組，包含y值，每一個對應於時間序列中的t。初值y0 在第一排。
infodict : 字典，只有full_output == True 時，才會返回。
字典包含額為的輸出信息。
鍵值：

『hu』 vector of step sizes successfully used for each time step.
『tcur』 vector with the value of t reached for each time step. (will always be at least as large as the input times).
『tolsf』 vector of tolerance scale factors, greater than 1.0, computed when a request for too much accuracy was detected.
『tsw』 value of t at the time of the last method switch (given for each time step)
『nst』 cumulative number of time steps
『nfe』 cumulative number of function evaluations for each time step
『nje』 cumulative number of jacobian evaluations for each time step
『nqu』 a vector of method orders for each successful step.
『imxer』index of the component of largest magnitude in the weighted local error vector (e / ewt) on an error return, -1 otherwise.
『lenrw』 the length of the double work array required.
『leniw』 the length of integer work array required.
『mused』a vector of method indicators for each successful time step: 1: adams (nonstiff), 2: bdf (stiff)
其他參數，官方網站和文檔都沒有明確說明。相關的資料，暫時也找不到。

6. python gradientboostingregressor可以做預測嗎

可以

最近項目中涉及基於Gradient Boosting Regression 演算法擬合時間序列曲線的內容，利用python機器學習包scikit-learn 中的GradientBoostingRegressor完成

因此就學習了下Gradient Boosting演算法，在這里分享下我的理解

Boosting 演算法簡介

Boosting演算法，我理解的就是兩個思想：

1）「三個臭皮匠頂個諸葛亮」，一堆弱分類器的組合就可以成為一個強分類器；

2）「知錯能改，善莫大焉」，不斷地在錯誤中學習，迭代來降低犯錯概率

當然，要理解好Boosting的思想，首先還是從弱學習演算法和強學習演算法來引入：

1）強學習演算法：存在一個多項式時間的學習演算法以識別一組概念，且識別的正確率很高；

2）弱學習演算法：識別一組概念的正確率僅比隨機猜測略好；

Kearns & Valiant證明了弱學習演算法與強學習演算法的等價問題，如果兩者等價，只需找到一個比隨機猜測略好的學習演算法，就可以將其提升為強學習演算法。

那麼是怎麼實現「知錯就改」的呢？

Boosting演算法，通過一系列的迭代來優化分類結果，每迭代一次引入一個弱分類器，來克服現在已經存在的弱分類器組合的shortcomings

在Adaboost演算法中，這個shortcomings的表徵就是權值高的樣本點

而在Gradient Boosting演算法中,這個shortcomings的表徵就是梯度

無論是Adaboost還是Gradient Boosting，都是通過這個shortcomings來告訴學習器怎麼去提升模型，也就是「Boosting」這個名字的由來吧

Adaboost演算法

Adaboost是由Freund 和 Schapire在1997年提出的，在整個訓練集上維護一個分布權值向量W,用賦予權重的訓練集通過弱分類演算法產生分類假設（基學習器）y(x),然後計算錯誤率,用得到的錯誤率去更新分布權值向量w,對錯誤分類的樣本分配更大的權值,正確分類的樣本賦予更小的權值。每次更新後用相同的弱分類演算法產生新的分類假設,這些分類假設的序列構成多分類器。對這些多分類器用加權的方法進行聯合,最後得到決策結果。

其結構如下圖所示：

可以發現，如果要用Gradient Boosting 演算法的話，在sklearn包里調用還是非常方便的，幾行代碼即可完成，大部分的工作應該是在特徵提取上。

感覺目前做數據挖掘的工作，特徵設計是最重要的，據說現在kaggle競賽基本是GBDT的天下，優劣其實還是特徵上，感覺做項目也是，不斷的在研究數據中培養對數據的敏感度。

7. 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>=0
3.全局優化
anneal ---模擬退火演算法
brute --強力法
4.標量函數
fminbound
brent
golden
bracket
5.擬合
curve_fit-- 使用非線性最小二乘法擬合
6.標量函數求根
brentq ---classic Brent (1973)
brenth ---A variation on the classic Brent（1980）ridder ---Ridder是提出這個演算法的人名
bisect ---二分法
newton ---牛頓法
fixed_point
7.多維函數求根
fsolve ---通用
broyden1 ---Broyden』s first Jacobian approximation.
broyden2 ---Broyden』s second Jacobian approximationnewton_krylov ---Krylov approximation for inverse Jacobiananderson ---extended Anderson mixing
excitingmixing ---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.000000
Iterations: 16
Function 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+8
x0 = [1.3]
xopt1 = fmin(myfunc, x0)
print xopt1
print
xopt2 = fmin_powell(myfunc, x0)
print xopt2
print
xopt3 = fmin_bfgs(myfunc, x0)
print xopt3
print
xopt4 = fmin_cg(myfunc,x0)
print xopt4
給出的結果是：
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 16
Function evaluations: 32
[ 2.00001953]
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 2
Function evaluations: 53
1.99999999997
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 2
Function evaluations: 12
Gradient evaluations: 4
[ 2.00000001]
Optimization terminated successfully.
Current function value: 4.000000
Iterations: 2
Function evaluations: 15
Gradient evaluations: 5
[ 2.]
我們可以根據給出的消息直觀的判斷演算法的執行情況。每一種演算法數學上的問題，請自己看書學習。個人感覺，如果不是純研究數學的工作，沒必要搞清楚那些推導以及定理雲雲。不過，必須了解每一種演算法的優劣以及能力所及。在使用的時候，不妨多種演算法都使用一下，看看效果分別如何，同時，還可以互相印證演算法失效的問題。
在from scipy.optimize import fmin之後，就可以使用help(fmin)來查看fmin的幫助信息了。幫助信息中沒有例子，但是給出了每一個參數的含義說明，這是調用函數時候的最有價值參考。
有源碼研究癖好的，或者當你需要改進這些已經實現的演算法的時候，可能需要查看optimize中的每種演算法的源代碼。在這里：https:/ / github. com/scipy/scipy/blob/master/scipy/optimize/optimize.py聰明的你肯定發現了，順著這個鏈接往上一級、再往上一級，你會找到scipy的幾乎所有源碼！

8. python 梯度下降法 怎麼用

import numpy as np
import matplotlib.pyplot as plt
import random

class dataMinning:
datasets = []
labelsets = []

addressD = '' #Data folder
addressL = '' #Label folder

npDatasets = np.zeros(1)
npLabelsets = np.zeros(1)

cost = []
numIterations = 0
alpha = 0
theta = np.ones(2)
#pCols = 0
#dRows = 0
def __init__(self,addressD,addressL,theta,numIterations,alpha,datasets=None):
if datasets is None:
self.datasets = []
else:
self.datasets = datasets
self.addressD = addressD
self.addressL = addressL
self.theta = theta
self.numIterations = numIterations
self.alpha = alpha

def readFrom(self):
fd = open(self.addressD,'r')
for line in fd:
tmp = line[:-1].split()
self.datasets.append([int(i) for i in tmp])
fd.close()
self.npDatasets = np.array(self.datasets)

fl = open(self.addressL,'r')
for line in fl:
tmp = line[:-1].split()
self.labelsets.append([int(i) for i in tmp])
fl.close()

tm = []
for item in self.labelsets:
tm = tm + item
self.npLabelsets = np.array(tm)

def genData(self,numPoints,bias,variance):
self.genx = np.zeros(shape = (numPoints,2))
self.geny = np.zeros(shape = numPoints)

for i in range(0,numPoints):
self.genx[i][0] = 1
self.genx[i][1] = i
self.geny[i] = (i + bias) + random.uniform(0,1) * variance

def gradientDescent(self):
xTrans = self.genx.transpose() #
i = 0
while i < self.numIterations:
hypothesis = np.dot(self.genx,self.theta)
loss = hypothesis - self.geny
#record the cost
self.cost.append(np.sum(loss ** 2))
#calculate the gradient
gradient = np.dot(xTrans,loss)
#updata, gradientDescent
self.theta = self.theta - self.alpha * gradient
i = i + 1

def show(self):
print 'yes'

if __name__ == "__main__":
c = dataMinning('c:\\city.txt','c:\\st.txt',np.ones(2),100000,0.000005)
c.genData(100,25,10)
c.gradientDescent()
cx = range(len(c.cost))
plt.figure(1)
plt.plot(cx,c.cost)
plt.ylim(0,25000)
plt.figure(2)
plt.plot(c.genx[:,1],c.geny,'b.')
x = np.arange(0,100,0.1)
y = x * c.theta[1] + c.theta[0]
plt.plot(x,y)
plt.margins(0.2)
plt.show()

9. Python 中numpy數組賦值和numpy.gradient的使用出錯，求解答

1. 看提示，T[i] = 280 - 8*z[i] / 1000 中提示 '-' 有問題，可能輸入了中文橫線。

2. 後面for i in range(0, 101) 這樣結尾需要增加 ' : ' 。

10. python怎麼出現陰影框

首先貼出代碼：

import solar
from gradient import *
from shadows import *
import numpy as np

import matplotlib.pyplot as plt # plt 用於顯示圖片
import matplotlib.image as mpimg # mpimg 用於讀取圖片

# dem
import srtm
if __name__ == '__main__':

'''
# 另一種從網上直接下載DEM數據
geo_elevation_data = srtm.get_data()
image = geo_elevation_data.get_image((500, 500), (45, 46), (13, 14), 300)
# the image s a standard PIL object, you can save or show it:
image.show()

image = np.asarray(image)

print(image.shape)

'''

# 讀入高程信息
filename = 'dempyrenees.asc'
dem = np.loadtxt(filename,skiprows=6,delimiter=' ')

# 高程信息的維度
# print(dem)
print(dem.shape)

# 定義一個光線向量
# 第一個表示和豎直方向的夾角，第二個表示由東向西照射
sv = normal_vector(45, 270)

# 生成陰影
shadow = project_shadows(dem=dem,sun_vector=sv,dx=30)
print(shadow[1,:])
print(shadow.shape)

# 顯示dem和shadow圖像
plt.figure()
plt.subplot(1,2,1)
plt.imshow(dem,cmap='gray') # 顯示灰度圖像
plt.axis('off') # 不顯示坐標軸

plt.subplot(1,2,2)
plt.imshow(shadow,cmap='gray')
plt.axis('off')

plt.show()
生成的結果如下：左邊是DEM數據，右邊是shadow



以上就是本文的全部內容，希望對大家的學習有所幫助。