pythonfiguresize

1. python的matplotlib的pyplot模塊，plt.yticks()設置刻度不能超過用來做圖的數據值了

python的matplotlib的pyplot模塊，plt.yticks()設置刻度不能超過用來做圖的數據值了。比較專業，要不然你可以問下老師或者專業人士。

2. 如何使用 Python 創建一個 NBA 得分圖

首先，我們需要獲得每個球員的投籃數據。利用 Savvas Tjortjoglou 貼出的代碼，筆者從 NBA.com 網站 API 上獲取了數據。在此不會貼出這個函數的結果。如果你感興趣，推薦你去看看 Savvas Tjortjoglou 的博客。

def aqcuire_shootingData(PlayerID,Season):
import requests
shot_chart_url = 'http://stats.nba.com/stats/shotchartdetail?CFID=33&CFPARAMS='+Season+'&ContextFilter='\
'&ContextMeasure=FGA&DateFrom=&DateTo=&GameID=&GameSegment=&LastNGames=0&LeagueID='\
'00&Location=&MeasureType=Base&Month=0&OpponentTeamID=0&Outcome=&PaceAdjust='\
'N&PerMode=PerGame&Period=0&PlayerID='+PlayerID+'&PlusMinus=N&Position=&Rank='\
'N&RookieYear=&Season='+Season+'&SeasonSegment=&SeasonType=Regular+Season&TeamID='\
'0&VsConference=&VsDivision=&mode=Advanced&showDetails=0&showShots=1&showZones=0'
response = requests.get(shot_chart_url)
headers = response.json()['resultSets'][0]['headers']
shots = response.json()['resultSets'][0]['rowSet']
shot_df = pd.DataFrame(shots, columns=headers)
return shot_df

接下來，我們需要繪制一個包含得分圖的籃球場圖。該籃球場圖例必須使用與NBA.com API 相同的坐標系統。例如，3分位置的投籃距籃筐必須為 X 單位，上籃距離籃筐則是 Y 單位。同樣，筆者再次使用了 Savvas Tjortjoglou 的代碼（哈哈，否則的話，搞明白 NBA.com 網站的坐標系統肯定會耗費不少的時間）。

def draw_court(ax=None, color='black', lw=2, outer_lines=False):
from matplotlib.patches import Circle, Rectangle, Arc
if ax is None:
ax = plt.gca()
hoop = Circle((0, 0), radius=7.5, linewidth=lw, color=color, fill=False)
backboard = Rectangle((-30, -7.5), 60, -1, linewidth=lw, color=color)
outer_box = Rectangle((-80, -47.5), 160, 190, linewidth=lw, color=color,
fill=False)
inner_box = Rectangle((-60, -47.5), 120, 190, linewidth=lw, color=color,
fill=False)
top_free_throw = Arc((0, 142.5), 120, 120, theta1=0, theta2=180,
linewidth=lw, color=color, fill=False)
bottom_free_throw = Arc((0, 142.5), 120, 120, theta1=180, theta2=0,
linewidth=lw, color=color, linestyle='dashed')
restricted = Arc((0, 0), 80, 80, theta1=0, theta2=180, linewidth=lw,
color=color)
corner_three_a = Rectangle((-220, -47.5), 0, 140, linewidth=lw,
color=color)
corner_three_b = Rectangle((220, -47.5), 0, 140, linewidth=lw, color=color)
three_arc = Arc((0, 0), 475, 475, theta1=22, theta2=158, linewidth=lw,
color=color)
center_outer_arc = Arc((0, 422.5), 120, 120, theta1=180, theta2=0,
linewidth=lw, color=color)
center_inner_arc = Arc((0, 422.5), 40, 40, theta1=180, theta2=0,
linewidth=lw, color=color)
court_elements = [hoop, backboard, outer_box, inner_box, top_free_throw,
bottom_free_throw, restricted, corner_three_a,
corner_three_b, three_arc, center_outer_arc,
center_inner_arc]
if outer_lines:
outer_lines = Rectangle((-250, -47.5), 500, 470, linewidth=lw,
color=color, fill=False)
court_elements.append(outer_lines)

for element in court_elements:
ax.add_patch(element)

ax.set_xticklabels([])
ax.set_yticklabels([])
ax.set_xticks([])
ax.set_yticks([])
return ax

我想創造一個不同位置的投籃百分比數組，因此決定利用 matplot 的 Hexbin 函數 http://matplotlib.org/api/pyplot_api.html 將投籃位置均勻地分組到六邊形中。該函數會對每個六邊形中每一個位置的投籃次數進行計數。

六邊形是均勻的分布在 XY 網格中。「gridsize」變數控制六邊形的數目。「extent」變數控制第一個和最後一個六邊形的繪制位置（一般來說第一個六邊形的位置基於第一個投籃的位置）。

計算命中率則需要對每個六邊形中投籃的次數和投籃得分次數進行計數，因此筆者對同一位置的投籃和得分數分別運行 hexbin 函數。然後，只需用每個位置的進球數除以投籃數。

def find_shootingPcts(shot_df, gridNum):
x = shot_df.LOC_X[shot_df['LOC_Y']<425.1] #i want to make sure to only include shots I can draw
y = shot_df.LOC_Y[shot_df['LOC_Y']<425.1]

x_made = shot_df.LOC_X[(shot_df['SHOT_MADE_FLAG']==1) & (shot_df['LOC_Y']<425.1)]
y_made = shot_df.LOC_Y[(shot_df['SHOT_MADE_FLAG']==1) & (shot_df['LOC_Y']<425.1)]

#compute number of shots made and taken from each hexbin location
hb_shot = plt.hexbin(x, y, gridsize=gridNum, extent=(-250,250,425,-50));
plt.close() #don't want to show this figure!
hb_made = plt.hexbin(x_made, y_made, gridsize=gridNum, extent=(-250,250,425,-50),cmap=plt.cm.Reds);
plt.close()

#compute shooting percentage
ShootingPctLocs = hb_made.get_array() / hb_shot.get_array()
ShootingPctLocs[np.isnan(ShootingPctLocs)] = 0 #makes 0/0s=0
return (ShootingPctLocs, hb_shot)

筆者非常喜歡 Savvas Tjortjoglou 在他的得分圖中加入了球員頭像的做法，因此也順道用了他的這部分代碼。球員照片會出現在得分圖的右下角。

def acquire_playerPic(PlayerID, zoom, offset=(250,400)):
from matplotlib import offsetbox as osb
import urllib
pic = urllib.urlretrieve("http://stats.nba.com/media/players/230x185/"+PlayerID+".png",PlayerID+".png")
player_pic = plt.imread(pic[0])
img = osb.OffsetImage(player_pic, zoom)
#img.set_offset(offset)
img = osb.AnnotationBbox(img, offset,xycoords='data',pad=0.0, box_alignment=(1,0), frameon=False)
return img

筆者想用連續的顏色圖來描述投籃進球百分比，紅圈越多代表著更高的進球百分比。雖然「紅」顏色圖示效果不錯，但是它會將0%的投籃進球百分比顯示為白色http://matplotlib.org/users/colormaps.html，而這樣顯示就會不明顯，所以筆者用淡粉紅色代表0%的命中率，因此對紅顏色圖做了下面的修改。

#cmap = plt.cm.Reds
#cdict = cmap._segmentdata
cdict = {
'blue': [(0.0, 0.6313725709915161, 0.6313725709915161), (0.25, 0.4470588266849518, 0.4470588266849518), (0.5, 0.29019609093666077, 0.29019609093666077), (0.75, 0.11372549086809158, 0.11372549086809158), (1.0, 0.05098039284348488, 0.05098039284348488)],
'green': [(0.0, 0.7333333492279053, 0.7333333492279053), (0.25, 0.572549045085907, 0.572549045085907), (0.5, 0.4156862795352936, 0.4156862795352936), (0.75, 0.0941176488995552, 0.0941176488995552), (1.0, 0.0, 0.0)],
'red': [(0.0, 0.9882352948188782, 0.9882352948188782), (0.25, 0.9882352948188782, 0.9882352948188782), (0.5, 0.9843137264251709, 0.9843137264251709), (0.75, 0.7960784435272217, 0.7960784435272217), (1.0, 0.40392157435417175, 0.40392157435417175)]
}

mymap = mpl.colors.LinearSegmentedColormap('my_colormap', cdict, 1024)

好了，現在需要做的就是將它們合並到一塊兒。下面所示的較大函數會利用上文描述的函數來創建一個描述投籃命中率的得分圖，百分比由紅圈表示（紅色越深 = 更高的命中率），投籃次數則由圓圈的大小決定（圓圈越大 = 投籃次數越多）。需要注意的是，圓圈在交疊之前都能增大。一旦圓圈開始交疊，就無法繼續增大。

在這個函數中，計算了每個位置的投籃進球百分比和投籃次數。然後畫出在該位置投籃的次數（圓圈大小）和進球百分比（圓圈顏色深淺）。

def shooting_plot(shot_df, plot_size=(12,8),gridNum=30):
from matplotlib.patches import Circle
x = shot_df.LOC_X[shot_df['LOC_Y']<425.1]
y = shot_df.LOC_Y[shot_df['LOC_Y']<425.1]

#compute shooting percentage and # of shots
(ShootingPctLocs, shotNumber) = find_shootingPcts(shot_df, gridNum)

#draw figure and court
fig = plt.figure(figsize=plot_size)#(12,7)
cmap = mymap #my modified colormap
ax = plt.axes([0.1, 0.1, 0.8, 0.8]) #where to place the plot within the figure
draw_court(outer_lines=False)
plt.xlim(-250,250)
plt.ylim(400, -25)

#draw player image
zoom = np.float(plot_size[0])/(12.0*2) #how much to zoom the player's pic. I have this hackily dependent on figure size
img = acquire_playerPic(PlayerID, zoom)
ax.add_artist(img)

#draw circles
for i, shots in enumerate(ShootingPctLocs):
restricted = Circle(shotNumber.get_offsets()[i], radius=shotNumber.get_array()[i],
color=cmap(shots),alpha=0.8, fill=True)
if restricted.radius > 240/gridNum: restricted.radius=240/gridNum
ax.add_patch(restricted)

#draw color bar
ax2 = fig.add_axes([0.92, 0.1, 0.02, 0.8])
cb = mpl.colorbar.ColorbarBase(ax2,cmap=cmap, orientation='vertical')
cb.set_label('Shooting %')
cb.set_ticks([0.0, 0.25, 0.5, 0.75, 1.0])
cb.set_ticklabels(['0%','25%', '50%','75%', '100%'])

plt.show()
return ax

好了，大功告成！因為筆者是森林狼隊的粉絲，在下面用幾分鍾跑出了森林狼隊前六甲的得分圖。

PlayerID = '203952' #andrew wiggins
shot_df = aqcuire_shootingData(PlayerID,'2015-16')
ax = shooting_plot(shot_df, plot_size=(12,8));

3. 強烈推薦一款Python可視化神器！強烈必備！

Plotly Express 是一個新的高級 Python 可視化庫：它是 Plotly.py 的高級封裝，它為復雜的圖表提供了一個簡單的語法。

受 Seaborn 和 ggplot2 的啟發，它專門設計為具有簡潔，一致且易於學習的 API ：只需一次導入，您就可以在一個函數調用中創建豐富的互動式繪圖，包括分面繪圖（faceting）、地圖、動畫和趨勢線。 它帶有數據集、顏色面板和主題，就像 Plotly.py 一樣。

Plotly Express 完全免費：憑借其寬松的開源 MIT 許可證，您可以隨意使用它（是的，甚至在商業產品中！）。

最重要的是，Plotly Express 與 Plotly 生態系統的其他部分完全兼容：在您的 Dash 應用程序中使用它，使用 Orca 將您的數據導出為幾乎任何文件格式，或使用JupyterLab 圖表編輯器在 GUI 中編輯它們！

用 pip install plotly_express 命令可以安裝 Plotly Express。

一旦導入Plotly Express（通常是 px ），大多數繪圖只需要一個函數調用，接受一個整潔的Pandas dataframe，並簡單描述你想要製作的圖。 如果你想要一個基本的散點圖，它只是 px.scatter（data，x =「column_name」，y =「column_name」）。

以下是內置的 Gapminder 數據集的示例，顯示2007年按國家/地區的人均預期壽命和人均GDP 之間的趨勢：

如果你想通過大陸區分它們，你可以使用 color 參數為你的點著色，由 px 負責設置默認顏色，設置圖例等：

這里的每一點都是一個國家，所以也許我們想要按國家人口來衡量這些點...... 沒問題：這里也有一個參數來設置，它被稱為 size：

如果你好奇哪個國家對應哪個點？ 可以添加一個 hover_name ，您可以輕松識別任何一點：只需將滑鼠放在您感興趣的點上即可！ 事實上，即使沒有 hover_name ，整個圖表也是互動的：

也可以通過 facet_col =」continent「 來輕松劃分各大洲，就像著色點一樣容易，並且讓我們使用 x軸 對數（log_x）以便在我們在圖表中看的更清晰：

也許你不僅僅對 2007年 感興趣，而且你想看看這張圖表是如何隨著時間的推移而演變的。 可以通過設置 animation_frame=「year」 （以及 animation_group =「country」 來標識哪些圓與控制條中的年份匹配）來設置動畫。

在這個最終版本中，讓我們在這里調整一些顯示，因為像「gdpPercap」 這樣的文本有點難看，即使它是我們的數據框列的名稱。 我們可以提供更漂亮的「標簽」 （labels），可以在整個圖表、圖例、標題軸和懸停（hovers）中應用。 我們還可以手動設置邊界，以便動畫在整個過程中看起來更棒：

因為這是地理數據，我們也可以將其表示為動畫地圖，因此這清楚地表明 Plotly Express 不僅僅可以繪制散點圖（不過這個數據集缺少前蘇聯的數據）。

事實上，Plotly Express 支持三維散點圖、三維線形圖、極坐標和地圖上三元坐標以及二維坐標。 條形圖（Bar）有二維笛卡爾和極坐標風格。

進行可視化時，您可以使用單變數設置中的直方圖（histograms）和箱形圖（box）或小提琴圖（violin plots），或雙變數分布的密度等高線圖（density contours）。 大多數二維笛卡爾圖接受連續或分類數據，並自動處理日期/時間數據。 可以查看我們的圖庫 (ref-3) 來了解每個圖表的例子。

數據 探索 的主要部分是理解數據集中值的分布，以及這些分布如何相互關聯。 Plotly Express 有許多功能來處理這些任務。

使用直方圖（histograms），箱形圖（box）或小提琴圖（violin plots）可視化單變數分布：

直方圖：

箱形圖：

小提琴圖：

還可以創建聯合分布圖（marginal rugs），使用直方圖，箱形圖（box）或小提琴來顯示雙變數分布，也可以添加趨勢線。 Plotly Express 甚至可以幫助你在懸停框中添加線條公式和R²值！ 它使用 statsmodels 進行普通最小二乘（OLS）回歸或局部加權散點圖平滑（LOWESS）。

在上面的一些圖中你會注意到一些不錯的色標。 在 Plotly Express 中， px.colors 模塊包含許多有用的色標和序列：定性的、序列型的、離散的、循環的以及所有您喜歡的開源包：ColorBrewer、cmocean 和 Carto 。 我們還提供了一些功能來製作可瀏覽的樣本供您欣賞（ref-3）：

定性的顏色序列：

眾多內置順序色標中的一部分：

我們特別為我們的互動式多維圖表感到自豪，例如散點圖矩陣（SPLOMS）、平行坐標和我們稱之為並行類別的並行集。 通過這些，您可以在單個圖中可視化整個數據集以進行數據 探索 。 在你的Jupyter 筆記本中查看這些單行及其啟用的交互：

散點圖矩陣（SPLOM）允許您可視化多個鏈接的散點圖：數據集中的每個變數與其他變數的關系。 數據集中的每一行都顯示為每個圖中的一個點。 你可以進行縮放、平移或選擇操作，你會發現所有圖都鏈接在一起！

平行坐標允許您同時顯示3個以上的連續變數。 dataframe 中的每一行都是一行。 您可以拖動尺寸以重新排序它們並選擇值范圍之間的交叉點。

並行類別是並行坐標的分類模擬：使用它們可視化數據集中多組類別之間的關系。

Plotly Express 之於 Plotly.py 類似 Seaborn 之於 matplotlib：Plotly Express 是一個高級封裝庫，允許您快速創建圖表，然後使用底層 API 和生態系統的強大功能進行修改。 對於Plotly 生態系統，這意味著一旦您使用 Plotly Express 創建了一個圖形，您就可以使用Themes，使用 FigureWidgets 進行命令性編輯，使用 Orca 將其導出為幾乎任何文件格式，或者在我們的 GUI JupyterLab 圖表編輯器中編輯它 。

主題（Themes）允許您控制圖形范圍的設置，如邊距、字體、背景顏色、刻度定位等。 您可以使用模板參數應用任何命名的主題或主題對象：

有三個內置的 Plotly 主題可以使用， 分別是 plotly， plotlywhite 和 plotlydark。

px 輸出繼承自 Plotly.py 的 Figure 類 ExpressFigure 的對象，這意味著你可以使用任何 Figure 的訪問器和方法來改變 px生成的繪圖。 例如，您可以將 .update（） 調用鏈接到 px 調用以更改圖例設置並添加註釋。 .update（） 現在返回修改後的數字，所以你仍然可以在一個很長的 Python 語句中執行此操作：

在這里，在使用 Plotly Express 生成原始圖形之後，我們使用 Plotly.py 的 API 來更改一些圖例設置並添加註釋。

Dash 是 Plotly 的開源框架，用於構建具有 Plotly.py 圖表的分析應用程序和儀錶板。Plotly Express 產生的對象與 Dash 100％兼容，只需將它們直接傳遞到 dash_core_components.Graph，如下所示： dcc.Graph（figure = px.scatter（...））。 這是一個非常簡單的 50行 Dash 應用程序的示例，它使用 px 生成其中的圖表：

這個 50 行的 Dash 應用程序使用 Plotly Express 生成用於瀏覽數據集的 UI 。

可視化數據有很多原因：有時您想要提供一些想法或結果，並且您希望對圖表的每個方面施加很多控制，有時您希望快速查看兩個變數之間的關系。 這是交互與 探索 的范疇。

Plotly.py 已經發展成為一個非常強大的可視化交互工具：它可以讓你控制圖形的幾乎每個方面，從圖例的位置到刻度的長度。 不幸的是，這種控制的代價是冗長的：有時可能需要多行 Python 代碼才能用 Plotly.py 生成圖表。

我們使用 Plotly Express 的主要目標是使 Plotly.py 更容易用於 探索 和快速迭代。

我們想要構建一個庫，它做出了不同的權衡：在可視化過程的早期犧牲一些控制措施來換取一個不那麼詳細的 API，允許你在一行 Python 代碼中製作各種各樣的圖表。 然而，正如我們上面所示，該控制項並沒有消失：你仍然可以使用底層的 Plotly.py 的 API 來調整和優化用 Plotly Express 製作的圖表。

支持這種簡潔 API 的主要設計決策之一是所有 Plotly Express 的函數都接受「整潔」的 dataframe 作為輸入。 每個 Plotly Express 函數都體現了dataframe 中行與單個或分組標記的清晰映射，並具有圖形啟發的語法簽名，可讓您直接映射這些標記的變數，如 x 或 y 位置、顏色、大小、 facet-column 甚至是 動畫幀到數據框（dataframe）中的列。 當您鍵入 px.scatter（data，x ='col1'，y='col2'） 時，Plotly Express 會為數據框中的每一行創建一個小符號標記 - 這就是 px.scatter 的作用 - 並將 「col1」 映射到 x 位置（類似於 y 位置）。 這種方法的強大之處在於它以相同的方式處理所有可視化變數：您可以將數據框列映射到顏色，然後通過更改參數來改變您的想法並將其映射到大小或進行行分面（facet-row）。

接受整個整潔的 dataframe 的列名作為輸入（而不是原始的 numpy 向量）也允許 px 為你節省大量的時間，因為它知道列的名稱，它可以生成所有的 Plotly.py 配置用於標記圖例、軸、懸停框、構面甚至動畫幀。 但是，如上所述，如果你的 dataframe 的列被笨拙地命名，你可以告訴 px 用每個函數的 labels 參數替換更好的。

僅接受整潔輸入所帶來的最終優勢是它更直接地支持快速迭代：您整理一次數據集，從那裡可以使用 px 創建數十種不同類型的圖表，包括在 SPLOM 中可視化多個維度 、使用平行坐標、在地圖上繪制，在二維、三維極坐標或三維坐標中使用等，所有這些都不需要重塑您的數據！

在 API 級別，我們在 px 中投入了大量的工作，以確保所有參數都被命名，以便在鍵入時最大限度地發現：所有 scatter -類似的函數都以 scatter 開頭（例如 scatter_polar， scatter_ternary）所以你可以通過自動補全來發現它們。 我們選擇拆分這些不同的散點圖函數，因此每個散點圖函數都會接受一組定製的關鍵字參數，特別是它們的坐標系。 也就是說，共享坐標系的函數集（例如 scatter， line ＆ bar，或 scatter_polar， line_polar 和 bar_polar ）也有相同的參數，以最大限度地方便學習。 我們還花了很多精力來提出簡短而富有表現力的名稱，這些名稱很好地映射到底層的 Plotly.py 屬性，以便於在工作流程中稍後調整到交互的圖表中。

最後，Plotly Express 作為一個新的 Python 可視化庫，在 Plotly 生態系統下，將會迅速發展。所以不要猶豫，立即開始使用 Plotly Express 吧！

4. Python的 matplotlib畫圖，怎麼把子圖的每個橫坐標顯示出來

ax = subplots(nrows,ncols,sharex,sharey,squeeze,subplot_kw,gridspec_kw,**fig_kw)

創建畫布和子圖。

nrows和ncols表示將畫布分割成幾行幾列 ，

sharex和sharey表是共用xy軸的設置。

squeeze bool

a.默認參數為True：額外的維度從返回的Axes(軸)對象中擠出，對於N*1或1*N個子圖，返回一個1維數組，對於N*M，N>1和M>1返回一個2維數組。

b.為False，不進行擠壓操作：返回一個元素為Axes實例的2維數組，即使它最終是1x1。

subplot_kw:字典類型，可選參數。把字典的關鍵字傳遞給add_subplot()來創建每個子圖。

subplot_kw:字典類型，可選參數。把字典的關鍵字傳遞給add_subplot()來創建每個子圖。

gridspec_kw:字典類型，可選參數。把字典的關鍵字傳遞給GridSpec構造函數創建子圖放在網格里(grid)。

**fig_kw：把所有詳細的關鍵字參數傳給figure()函數。

可見你沒有辦法單獨設置某個子圖的ax的。

5. 利用Python實現卷積神經網路的可視化

在本文中，將探討如何可視化卷積神經網路（CNN），該網路在計算機視覺中使用最為廣泛。首先了解CNN模型可視化的重要性，其次介紹可視化的幾種方法，同時以一個用例幫助讀者更好地理解模型可視化這一概念。

正如上文中介紹的癌症腫瘤診斷案例所看到的，研究人員需要對所設計模型的工作原理及其功能掌握清楚，這點至關重要。一般而言，一名深度學習研究者應該記住以下幾點：

1.1 理解模型是如何工作的

1.2 調整模型的參數

1.3 找出模型失敗的原因

1.4 向消費者/終端用戶或業務主管解釋模型做出的決定

2.可視化CNN模型的方法

根據其內部的工作原理，大體上可以將CNN可視化方法分為以下三類：

初步方法：一種顯示訓練模型整體結構的簡單方法

基於激活的方法：對單個或一組神經元的激活狀態進行破譯以了解其工作過程

基於梯度的方法：在訓練過程中操作前向傳播和後向傳播形成的梯度

下面將具體介紹以上三種方法，所舉例子是使用Keras深度學習庫實現，另外本文使用的數據集是由「識別數字」競賽提供。因此，讀者想復現文中案例時，請確保安裝好Kears以及執行了這些步驟。

研究者能做的最簡單的事情就是繪制出模型結構圖，此外還可以標注神經網路中每層的形狀及參數。在keras中，可以使用如下命令完成模型結構圖的繪制：

model.summary()_________________________________________________________________Layer (type)                 Output Shape              Param #  

=================================================================conv2d_1 (Conv2D)            (None, 26, 26, 32)        320_________________________________________________________________conv2d_2 (Conv2D)            (None, 24, 24, 64)        18496_________________________________________________________________max_pooling2d_1 (MaxPooling2 (None, 12, 12, 64)        0_________________________________________________________________dropout_1 (Dropout)          (None, 12, 12, 64)        0_________________________________________________________________flatten_1 (Flatten)          (None, 9216)              0_________________________________________________________________dense_1 (Dense)              (None, 128)               1179776_________________________________________________________________dropout_2 (Dropout)          (None, 128)               0_________________________________________________________________preds (Dense)                (None, 10)                1290      

=================================================================Total params: 1,199,882Trainable params: 1,199,882Non-trainable params: 0

還可以用一個更富有創造力和表現力的方式呈現模型結構框圖，可以使用keras.utils.vis_utils函數完成模型體系結構圖的繪制。

另一種方法是繪制訓練模型的過濾器，這樣就可以了解這些過濾器的表現形式。例如，第一層的第一個過濾器看起來像：

top_layer = model.layers[0]plt.imshow(top_layer.get_weights()[0][:, :, :, 0].squeeze(), cmap='gray')

一般來說，神經網路的底層主要是作為邊緣檢測器，當層數變深時，過濾器能夠捕捉更加抽象的概念，比如人臉等。

為了理解神經網路的工作過程，可以在輸入圖像上應用過濾器，然後繪制其卷積後的輸出，這使得我們能夠理解一個過濾器其特定的激活模式是什麼。比如，下圖是一個人臉過濾器，當輸入圖像是人臉圖像時候，它就會被激活。

from vis.visualization import visualize_activation

from vis.utils import utils

from keras import activations

from matplotlib import pyplot as plt

%matplotlib inline

plt.rcParams['figure.figsize'] = (18, 6)

# Utility to search for layer index by name.

# Alternatively we can specify this as -1 since it corresponds to the last layer.

layer_idx = utils.find_layer_idx(model, 'preds')

# Swap softmax with linear

model.layers[layer_idx].activation = activations.linear

model = utils.apply_modifications(model)

# This is the output node we want to maximize.filter_idx = 0

img = visualize_activation(model, layer_idx, filter_indices=filter_idx)

plt.imshow(img[..., 0])

同理，可以將這個想法應用於所有的類別，並檢查它們的模式會是什麼樣子。

for output_idx in np.arange(10):

  # Lets turn off verbose output this time to avoid clutter and just see the output.

  img = visualize_activation(model, layer_idx, filter_indices=output_idx, input_range=(0., 1.))

  plt.figure()

  plt.title('Networks perception of {}'.format(output_idx))

  plt.imshow(img[..., 0])

在圖像分類問題中，可能會遇到目標物體被遮擋，有時候只有物體的一小部分可見的情況。基於圖像遮擋的方法是通過一個灰色正方形系統地輸入圖像的不同部分並監視分類器的輸出。這些例子清楚地表明模型在場景中定位對象時，若對象被遮擋，其分類正確的概率顯著降低。

為了理解這一概念，可以從數據集中隨機抽取圖像，並嘗試繪制該圖的熱圖（heatmap）。這使得我們直觀地了解圖像的哪些部分對於該模型而言的重要性，以便對實際類別進行明確的區分。

def iter_occlusion(image, size=8):

    # taken from https://www.kaggle.com/blargl/simple-occlusion-and-saliency-maps

  occlusion = np.full((size * 5, size * 5, 1), [0.5], np.float32)

  occlusion_center = np.full((size, size, 1), [0.5], np.float32)

  occlusion_padding = size * 2

  # print('padding...')

  image_padded = np.pad(image, ( \  (occlusion_padding, occlusion_padding), (occlusion_padding, occlusion_padding), (0, 0) \  ), 'constant', constant_values = 0.0)

  for y in range(occlusion_padding, image.shape[0] + occlusion_padding, size):

      for x in range(occlusion_padding, image.shape[1] + occlusion_padding, size):

          tmp = image_padded.()

          tmp[y - occlusion_padding:y + occlusion_center.shape[0] + occlusion_padding, \

            x - occlusion_padding:x + occlusion_center.shape[1] + occlusion_padding] \            = occlusion

          tmp[y:y + occlusion_center.shape[0], x:x + occlusion_center.shape[1]] = occlusion_center          yield x - occlusion_padding, y - occlusion_padding, \

            tmp[occlusion_padding:tmp.shape[0] - occlusion_padding, occlusion_padding:tmp.shape[1] - occlusion_padding]i = 23 # for exampledata = val_x[i]correct_class = np.argmax(val_y[i])

# input tensor for model.predictinp = data.reshape(1, 28, 28, 1)# image data for matplotlib's imshowimg = data.reshape(28, 28)

# occlusionimg_size = img.shape[0]

occlusion_size = 4print('occluding...')heatmap = np.zeros((img_size, img_size), np.float32)class_pixels = np.zeros((img_size, img_size), np.int16)

from collections import defaultdict

counters = defaultdict(int)for n, (x, y, img_float) in enumerate(iter_occlusion(data, size=occlusion_size)):

    X = img_float.reshape(1, 28, 28, 1)

    out = model.predict(X)

    #print('#{}: {} @ {} (correct class: {})'.format(n, np.argmax(out), np.amax(out), out[0][correct_class]))

    #print('x {} - {} | y {} - {}'.format(x, x + occlusion_size, y, y + occlusion_size))

    heatmap[y:y + occlusion_size, x:x + occlusion_size] = out[0][correct_class]

    class_pixels[y:y + occlusion_size, x:x + occlusion_size] = np.argmax(out)

    counters[np.argmax(out)] += 1

正如之前的坦克案例中看到的那樣，怎麼才能知道模型側重於哪部分的預測呢？為此，可以使用顯著圖解決這個問題。顯著圖首先在這篇文章中被介紹。

使用顯著圖的概念相當直接——計算輸出類別相對於輸入圖像的梯度。這應該告訴我們輸出類別值對於輸入圖像像素中的微小變化是怎樣變化的。梯度中的所有正值告訴我們，像素的一個小變化會增加輸出值。因此，將這些梯度可視化可以提供一些直觀的信息，這種方法突出了對輸出貢獻最大的顯著圖像區域。

class_idx = 0indices = np.where(val_y[:, class_idx] == 1.)[0]

# pick some random input from here.idx = indices[0]

# Lets sanity check the picked image.from matplotlib import pyplot as plt%matplotlib inline

plt.rcParams['figure.figsize'] = (18, 6)plt.imshow(val_x[idx][..., 0])

from vis.visualization import visualize_saliency

from vis.utils import utilsfrom keras import activations# Utility to search for layer index by name.

# Alternatively we can specify this as -1 since it corresponds to the last layer.

layer_idx = utils.find_layer_idx(model, 'preds')

# Swap softmax with linearmodel.layers[layer_idx].activation = activations.linear

model = utils.apply_modifications(model)grads = visualize_saliency(model, layer_idx, filter_indices=class_idx, seed_input=val_x[idx])

# Plot with 'jet' colormap to visualize as a heatmap.plt.imshow(grads, cmap='jet')

# This corresponds to the Dense linear layer.for class_idx in np.arange(10):

    indices = np.where(val_y[:, class_idx] == 1.)[0]

    idx = indices[0]

    f, ax = plt.subplots(1, 4)

    ax[0].imshow(val_x[idx][..., 0])

    for i, modifier in enumerate([None, 'guided', 'relu']):

        grads = visualize_saliency(model, layer_idx, filter_indices=class_idx,

        seed_input=val_x[idx], backprop_modifier=modifier)

        if modifier is None:

            modifier = 'vanilla'

        ax[i+1].set_title(modifier)

        ax[i+1].imshow(grads, cmap='jet')

類別激活映射（CAM）或grad-CAM是另外一種可視化模型的方法，這種方法使用的不是梯度的輸出值，而是使用倒數第二個卷積層的輸出，這樣做是為了利用存儲在倒數第二層的空間信息。

from vis.visualization import visualize_cam

# This corresponds to the Dense linear layer.for class_idx in np.arange(10):

indices = np.where(val_y[:, class_idx] == 1.)[0]

idx = indices[0]f, ax = plt.subplots(1, 4)

ax[0].imshow(val_x[idx][..., 0])

for i, modifier in enumerate([None, 'guided', 'relu']):

    grads = visualize_cam(model, layer_idx, filter_indices=class_idx,

    seed_input=val_x[idx], backprop_modifier=modifier)

    if modifier is None:

        modifier = 'vanilla'

    ax[i+1].set_title(modifier)

    ax[i+1].imshow(grads, cmap='jet')

本文簡單說明了CNN模型可視化的重要性，以及介紹了一些可視化CNN網路模型的方法，希望對讀者有所幫助，使其能夠在後續深度學習應用中構建更好的模型。 免費視頻教程：www.mlxs.top

6. python matplotlib的坐標軸怎麼設置范圍

plt.ylim(24.9,25.2)

7. python 繪制和密度圖筆記

import pandasas pd

import numpyas np

import seabornas sns

import matplotlib.pyplotas plt

pd.set_option('display.max_columns', 10000)

pd.set_option('display.max_rows', 10000000000)

pd.set_option('display.width', 100000)

income = pd.read_excel(r'D:\bigData\0629demo\dataSource\income.xlsx')

fill_data = income.fillna(value={'workclass': income.workclass.mode()[0], 'occupation': income.occupation.mode()[0],

                                'native-country': income['native-country'].mode()[0]}, inplace=True)

# print(income.apply(lambda x: np.sum(x.isnull())))

# print(income)

print(income.describe())

print(income.describe(include=['object']))

# 設置繪圖風格

plt.style.use('ggplot')

# 設置多圖形組合

fig, axes = plt.subplots(2, 1)

# 繪制不同收入水平下的年齡核密度圖

# kind='kde', label='<=50K', ax=axes[0], legend=True, linestyle='-'

# kind='kde', label='>50K', ax=axes[0], legend=True, linestyle='--'

income['age'][income.income ==' <=50K'].plot(kind='kde', ax=axes[0], label='<=50K', legend=True, linestyle='-')

income['age'][income.income ==' >50K'].plot(kind='kde', ax=axes[0], label='>50K', legend=True, linestyle='--')

# 繪制不同收入水平下的周工作小時數核密度圖

# kind='kde', label='<= 50K', ax=axes[1], legend=True,  linestyle='-'

# kind='kde', label='> 50K', ax=axes[1], legend=True, linestyle='--'

income['hours-per-week'][income.income ==' <=50K'].plot(kind='kde', label='<= 50K', ax=axes[1], legend=True,

                                                        linestyle='-')

income['hours-per-week'飢肢][income.income ==' >50K'].plot(kind='kde', label='> 50K', ax=axes[1], legend=True,

               高基                                         linestyle='--')

plt.show()

# 構造不同收入水平下各種族人數的數據

race = pd.DataFrame(income.groupby(by=['race', 'income']).agg(np.size).loc[:, 'age'])

# 重設行索引

race = race.reset_index()

# 變數重命名

race.rename(columns={'age':'戚肢謹counts'}, inplace=True)

print(race)

# 排序

race.sort_values(by=['race', 'counts'], ascending=False, inplace=True)

# 構造不同收入水平下各家庭關系人數的數據

relationship = pd.DataFrame(income.groupby(by=['relationship', 'income']).agg(np.size).loc[:, 'age'])

relationship = relationship.reset_index()

relationship.rename(columns={'age':'counts'}, inplace=True)

relationship.sort_values(by=['relationship', 'counts'], ascending=False, inplace=True)

plt.figure(figsize=(15, 10))

sns.barplot(x='race', y='counts', hue='income', data=race)

plt.show()

plt.figure(figsize=(15, 10))

sns.barplot(x='relationship', y='counts', hue='income', data=relationship)

plt.show()

8. python裡面一些簡單代碼的含義是什麼（題主零基礎）

主要就兩個文件 一個是sample的名字 labels.txt
還有個放矩陣 predict.txt 兩列，一列pre 二列true
放矩陣那裡他會調confusion_matrix自己算，如果你自己算好了不需要算，那代碼就要改
confusion_matrix介紹見
http://scikit-learn.org/stable/moles/generated/sklearn.metrics.confusion_matrix.html
這東西用R畫快多了，python的也只是剛才看了下介紹，應該沒啥大問題

9. Python matplotlib用繪制雷達圖實戰案例

import pandasas pd

import matplotlib.pyplotas plt

import numpyas np

plt.rcParams['font.sans-serif'] = ['Microsoft YaHei']

plt.rcParams['axes.unicode_minus'] =False

data = pd.read_csv(r'D:\bigData\radarMap.csv')

data = data.dropna(axis=1)

data = data.set_index('性能評價指標')

data = data.T

data.index.name ='品牌'

def plot_radar(data, feature):

columns = ['動力性', '燃油經濟性', '制動性', '操控穩定性', '行駛平順性', '通過性', '安全性', '環保性', '方便性', '舒適性', '經濟性', '容量性']

colors = ['r', 'g', 'y']

# 設置雷達圖的角度，用於平分切開一明旅個平面

    # linspace(1,10,x) 創建1-10的等差數組,個數為 x，默認50個;endpoint參數指定是否包含終值，默認值為True，即包含終值。

    angles = np.linspace(0.1 * np.pi, 2.1 * np.pi, len(columns), endpoint=False)

# 使雷達圖封閉起來

    angles = np.concatenate((angles, [angles[0]]))

# figsize:指定figure的寬和高，單位為英寸；

    figure = plt.figure(figsize=(6, 6))

# 設置為極坐標格式;subplot(nrows,ncols,sharex,sharey,subplot_kw,**fig_kw)創建單個子圖,下面兩句效果相同

    ax = figure.add_subplot(111, polar=True)

for i, cin enumerate(feature):

stats = data.loc[c]

stats = np.concatenate((stats, [stats[0]]))

ax.plot(angles, stats, '-', linewidth=2, c=colors[i], label=str(c))

ax.fill(angles, stats, color=colors[i], alpha=0.75)

# bbox_to_anchor這個參數，可以把圖例放在圖外面

    # bbox_to_anchor：表示legend的位置，前一個表示左右，後一個表示上下。

    # 當使用這個參數時。loc將不再起正常的作用，ncol=3表示圖例三列顯示。

    ax.legend(loc=4, bbox_to_anchor=(1.15, -0.07))

# 設置極軸范圍

    ax.set_ylim(0, 10)

# ax.set_yticklabels([2, 4, 6, 8, 10])

    # 添加每個特質的標簽

    columns = np.concatenate((columns, [columns[0]]))

ax.set_thetagrids(angles *180 / np.pi, columns, fontsize=12)

# 添加標題

    plt.title('汽車性能州纖指標雷達圖')

plt.show()

return figure

figure = plot_radar(data, ['A品牌', 'B品牌', 'C品牌激跡凳'])

10. python matplotlib數據作圖

一、使用numpy生成長度為100的等差序列作為自變數，命名為x，並使用三角函數SiNx和cosx**2生成兩個因變數，命名為y和Z。