pythoncnn分類

A. 利用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

B. 怎樣用python構建一個卷積神經網路

用keras框架較為方便

首先安裝anaconda，然後通過pip安裝keras

C. cnn卷積神經網路用什麼語言來寫pascial

200+
這個是hinton matlab代碼的C++改寫版. convnetjs - Star,SAE，首選的肯定是LIBSVM這個庫;RBM#47. DeepLearn Toolbox - Star，包括了CNN;C++SVM方面,Java。
2。
下面主要一些DeepLearning的GitHub項目吧;SdA#47:2200+
實現了卷積神經網路，還實現了Rasmussen的共軛梯度Conjugate Gradient演算法,DBN,C/CRBM/CDBN#47：Python。
3,CAE等主流模型，實現的模型有DBN#47，可以用來做分類，語言是Python;LR等，從演算法與實現上都比較全:800+
實現了深度學習網路. rbm-mnist - Star，應該是應用最廣的機器學習庫了，強化學習等. Deep Learning(yusugomo) - Star,Scala:1000+
Matlab實現中最熱的庫存，提供了5種語言的實現。
5;dA#47:500+
這是同名書的配套代碼。
4. Neural-Networks-And-Deep-Learning - Star！
1，回歸

D. python學科課程分幾個部分

以下是老男孩教育Python全棧課程內容：
階段一：Python開發基礎
Python開發基礎課程內容包括：計算機硬體、操作系統原理、安裝linux操作系統、linux操作系統維護常用命令、Python語言介紹、環境安裝、基本語法、基本數據類型、二進制運算、流程式控制制、字元編碼、文件處理、數據類型、用戶認證、三級菜單程序、購物車程序開發、函數、內置方法、遞歸、迭代器、裝飾器、內置方法、員工信息表開發、模塊的跨目錄導入、常用標准庫學習，b加密\re正則\logging日誌模塊等，軟體開發規范學習，計算器程序、ATM程序開發等。
階段二：Python高級級編編程&資料庫開發
Python高級級編編程&資料庫開發課程內容包括：面向對象介紹、特性、成員變數、方法、封裝、繼承、多態、類的生成原理、MetaClass、__new__的作用、抽象類、靜態方法、類方法、屬性方法、如何在程序中使用面向對象思想寫程序、選課程序開發、TCP/IP協議介紹、Socket網路套接字模塊學習、簡單遠程命令執行客戶端開發、C\S架構FTP伺服器開發、線程、進程、隊列、IO多路模型、資料庫類型、特性介紹，表欄位類型、表結構構建語句、常用增刪改查語句、索引、存儲過程、視圖、觸發器、事務、分組、聚合、分頁、連接池、基於資料庫的學員管理系統開發等。
階段三：前端開發
前端開發課程內容包括：HTML\CSS\JS學習、DOM操作、JSONP、原生Ajax非同步載入、購物商城開發、Jquery、動畫效果、事件、定時期、輪播圖、跑馬燈、HTML5\CSS3語法學習、bootstrap、抽屜新熱榜開發、流行前端框架介紹、Vue架構剖析、mvvm開發思想、Vue數據綁定與計算屬性、條件渲染類與樣式綁定、表單控制項綁定、事件綁定webpack使用、vue-router使用、vuex單向數據流與應用結構、vuex actions與mutations熱重載、vue單頁面項目實戰開發等。
階段四：WEB框架開發
WEB框架開發課程內容包括：Web框架原理剖析、Web請求生命周期、自行開發簡單的Web框架、MTV\MVC框架介紹、Django框架使用、路由系統、模板引擎、FBV\CBV視圖、Models ORM、FORM、表單驗證、Django session & cookie、CSRF驗證、XSS、中間件、分頁、自定義tags、Django Admin、cache系統、信號、message、自定義用戶認證、Memcached、redis緩存學習、RabbitMQ隊列學習、Celery分布式任務隊列學習、Flask框架、Tornado框架、Restful API、BBS+Blog實戰項目開發等。
階段五：爬蟲開發
爬蟲開發課程內容包括：Requests模塊、BeautifulSoup，Selenium模塊、PhantomJS模塊學習、基於requests實現登陸：抽屜、github、知乎、博客園、爬取拉鉤職位信息、開發Web版微信、高性能IO性能相關模塊：asyncio、aiohttp、grequests、Twisted、自定義開發一個非同步非阻塞模塊、驗證碼圖像識別、Scrapy框架以及源碼剖析、框架組件介紹（engine、spider、downloader、scheler、pipeline）、分布式爬蟲實戰等。
階段六：全棧項目實戰
全棧項目實戰課程內容包括：互聯網企業專業開發流程講解、git、github協作開發工具講解、任務管理系統講解、介面單元測試、敏捷開發與持續集成介紹、django + uwsgi + nginx生產環境部署學習、介面文檔編寫示例、互聯網企業大型項目架構圖深度講解、CRM客戶關系管理系統開發、路飛學城在線教育平台開發等。
階段七：數據分析
數據分析課程內容包括：金融、股票知識入門股票基本概念、常見投資工具介紹、市基本交易規則、A股構成等，K線、平均線、KDJ、MACD等各項技術指標分析，股市操作模擬盤演示量化策略的開發流程，金融量化與Python，numpy、pandas、matplotlib模塊常用功能學習在線量化投資平台：優礦、聚寬、米筐等介紹和使用、常見量化策略學習，如雙均線策略、因子選股策略、因子選股策略、小市值策略、海龜交易法則、均值回歸、策略、動量策略、反轉策略、羊駝交易法則、PEG策略等、開發一個簡單的量化策略平台，實現選股、擇時、倉位管理、止盈止損、回測結果展示等功能。
階段八：人工智慧
人工智慧課程內容包括：機器學習要素、常見流派、自然語言識別、分析原理詞向量模型word2vec、剖析分類、聚類、決策樹、隨機森林、回歸以及神經網路、測試集以及評價標准Python機器學習常用庫scikit-learn、數據預處理、Tensorflow學習、基於Tensorflow的CNN與RNN模型、Caffe兩種常用數據源製作、OpenCV庫詳解、人臉識別技術、車牌自動提取和遮蔽、無人機開發、Keras深度學習、貝葉斯模型、無人駕駛模擬器使用和開發、特斯拉遠程式控制制API和自動化駕駛開發等。
階段九：自動化運維&開發
自動化運維&開發課程內容包括：設計符合企業實際需求的CMDB資產管理系統，如安全API介面開發與使用，開發支持windows和linux平台的客戶端，對其它系統開放靈活的api設計與開發IT資產的上線、下線、變更流程等業務流程。IT審計+主機管理系統開發，真實企業系統的用戶行為、管理許可權、批量文件操作、用戶登錄報表等。分布式主機監控系統開發，監控多個服務，多種設備，報警機制，基於http+restful架構開發，實現水平擴展，可輕松實現分布式監控等功能。
階段十：高並發語言GO開發高並發語言GO開發課程內容包括：Golang的發展介紹、開發環境搭建、golang和其他語言對比、字元串詳解、條件判斷、循環、使用數組和map數據類型、go程序編譯和Makefile、gofmt工具、godoc文檔生成工具詳解、斐波那契數列、數據和切片、make&new、字元串、go程序調試、slice&map、map排序、常用標准庫使用、文件增刪改查操作、函數和面向對象詳解、並發、並行與goroute、channel詳解goroute同步、channel、超時與定時器reover捕獲異常、Go高並發模型、Lazy生成器、並發數控制、高並發web伺服器的開發等。

E. 使用python在GPU上構建和訓練卷積神經網路

我將對代碼進行補充演練，以構建在數據集上訓練的任何類型的圖像分類器。在這個例子中，我將使用花卉數據集，其中包括102種不同類型的花。需要數據集和代碼都可以私信我。

Pytorch是機器學習和Python上的免費軟體包，非常易於使用。語法模擬numpy，因此，如果你在python中有一些科學計算經驗，那麼會相當有用的。賀寬只需幾行代碼，就可以下載預先訓練的數據集，使用定義的變換對圖像進叢襲行標准化，然後運行訓練。

創建和擴充數據集

為了增加數據集，我使用' google_images_download'API 從互聯網上下載了相關圖像。顯然，您可以使用此API不僅可以擴充現有數據集，還可以從頭開始創建自己的數據集。

確保從圖像中挑選出異常值(損壞的文件或偶然出現的無關圖像)。

圖像標准化

為了使圖像具有相同的大小和像素變化，可以使用pytorch的transfors模塊：

轉移學習

從頭開始訓練的模型可能不是最明智的選擇，因為有許多網路可用於各種數據集。簡單地說，像edge-和其他簡單形狀檢測器等低級特徵對於不同的模型是相似的，即使clasificators是針對不同目的進行訓練的。在本項目中，我使用了一個預訓練網路Resnet152，只有最後一個完全連接的層重新用於新任務，即使這樣也會產生相當好的效果。

在這里，我將除最後一層之外的所有層都設置為具有固定權重（requires_grad = False），因此只有最後層中的參數將通過梯度下降進行更新。

訓練模型

下面介紹一下進行訓練的函數：

如何獲得GPU？

當然，對CPU的訓練太慢了。根據我自己的經驗，在GPU僅需要一個小時就可以完成12次訓練周期，但是在CPU上相同數量的訓練周期可能需要花費大約15個小時。

如果您沒有本地可用的GPU，則可以考慮使用雲GPU。為了加速禪鄭亮CNN的訓練，我使用了floydhub（www.floydhub.com）上提供的雲GPU 。

這項服務非常指的使用：總有很好的文檔和大量的提示，所以你會很清楚的知道下一步需要如何去做。在floydhub上對於使用GPU的收費也是可以接受的。

首先，需要將數據集上傳到伺服器

然後，需要創建項目。需要在計算機上安裝floydhub客戶端，將數據集上載到其網站並在終端中運行以下命令：

其中'username'是您的登錄名，'i'是數據集所在的文件夾。

這樣子在訓練網路時就會很輕鬆了

結果和改進想法

得到的模型在數據集上訓練了1.5小時，並在驗證數據集上達到了95％的准確度。

F. python機器學習庫怎麼使用

1. Scikit-learn（重點推薦）
www .github .com/scikit-learn/scikit-learn
Scikit-learn 是基於Scipy為機器學習建造的的一個Python模塊，他的特色就是多樣化的分類，回歸和聚類的演算法包括支持向量機，邏輯回歸，樸素貝葉斯分類器，隨機森林，Gradient Boosting，聚類演算法和DBSCAN。而且也設計出了Python numerical和scientific libraries Numpy and Scipy2、Keras（深度學習）
https://github.com/fchollet/keras
Keras是基於Theano的一個深度學習框架，它的設計參考了Torch，用Python語言編寫，是一個高度模塊化的神經網路庫，支持GPU和CPU。
3、Lasagne（深度學習）
不只是一個美味的義大利菜，也是一個和Keras有著相似功能的深度學習庫，但其在設計上與它們有些不同。
4.Pylearn2
www .github .com/lisa-lab/pylearn2
Pylearn是一個讓機器學習研究簡單化的基於Theano的庫程序。它把深度學習和人工智慧研究許多常用的模型以及訓練演算法封裝成一個單一的實驗包，如隨機梯度下降。
5.NuPIC
www .github .com/numenta/nupic
NuPIC是一個以HTM學習演算法為工具的機器智能平台。HTM是皮層的精確計算方法。HTM的核心是基於時間的持續學習演算法和儲存和撤銷的時空模式。NuPIC適合於各種各樣的問題,尤其是檢測異常和預測的流數據來源。
6. Nilearn
www .github .com/nilearn/nilearn
Nilearn 是一個能夠快速統計學習神經影像數據的Python模塊。它利用Python語言中的scikit-learn 工具箱和一些進行預測建模，分類，解碼，連通性分析的應用程序來進行多元的統計。
7.PyBrain
www .github .com/pybrain/pybrain
Pybrain是基於Python語言強化學習，人工智慧，神經網路庫的簡稱。 它的目標是提供靈活、容易使用並且強大的機器學習演算法和進行各種各樣的預定義的環境中測試來比較你的演算法。
8.Pattern
www .github .com/clips/pattern
Pattern 是Python語言下的一個網路挖掘模塊。它為數據挖掘，自然語言處理，網路分析和機器學習提供工具。它支持向量空間模型、聚類、支持向量機和感知機並且用KNN分類法進行分類。
9.Fuel
www .github .com/mila-udem/fuel
Fuel為你的機器學習模型提供數據。他有一個共享如MNIST, CIFAR-10 (圖片數據集), Google's One Billion Words (文字)這類數據集的介面。你使用他來通過很多種的方式來替代自己的數據。
10.Bob
www .github .com/idiap/bob
Bob是一個免費的信號處理和機器學習的工具。它的工具箱是用Python和C++語言共同編寫的，它的設計目的是變得更加高效並且減少開發時間，它是由處理圖像工具,音頻和視頻處理、機器學習和模式識別的大量軟體包構成的。
11.Skdata
www .github .com/jaberg/skdata
Skdata是機器學習和統計的數據集的庫程序。這個模塊對於玩具問題，流行的計算機視覺和自然語言的數據集提供標準的Python語言的使用。
12.MILK
www .github .com/luispedro/milk
MILK是Python語言下的機器學習工具包。它主要是在很多可得到的分類比如SVMS,K-NN,隨機森林，決策樹中使用監督分類法。 它還執行特徵選擇。 這些分類器在許多方面相結合,可以形成不同的例如無監督學習、密切關系金傳播和由MILK支持的K-means聚類等分類系統。
13.IEPY
www .github .com/machinalis/iepy
IEPY是一個專注於關系抽取的開源性信息抽取工具。它主要針對的是需要對大型數據集進行信息提取的用戶和想要嘗試新的演算法的科學家。
14.Quepy
www .github .com/machinalis/quepy
Quepy是通過改變自然語言問題從而在資料庫查詢語言中進行查詢的一個Python框架。他可以簡單的被定義為在自然語言和資料庫查詢中不同類型的問題。所以，你不用編碼就可以建立你自己的一個用自然語言進入你的資料庫的系統。
現在Quepy提供對於Sparql和MQL查詢語言的支持。並且計劃將它延伸到其他的資料庫查詢語言。
15.Hebel
www .github .com/hannes-brt/hebel
Hebel是在Python語言中對於神經網路的深度學習的一個庫程序，它使用的是通過PyCUDA來進行GPU和CUDA的加速。它是最重要的神經網路模型的類型的工具而且能提供一些不同的活動函數的激活功能，例如動力，涅斯捷羅夫動力，信號丟失和停止法。
16.mlxtend
www .github .com/rasbt/mlxtend
它是一個由有用的工具和日常數據科學任務的擴展組成的一個庫程序。
17.nolearn
www .github .com/dnouri/nolearn
這個程序包容納了大量能對你完成機器學習任務有幫助的實用程序模塊。其中大量的模塊和scikit-learn一起工作，其它的通常更有用。
18.Ramp
www .github .com/kvh/ramp
Ramp是一個在Python語言下制定機器學習中加快原型設計的解決方案的庫程序。他是一個輕型的pandas-based機器學習中可插入的框架，它現存的Python語言下的機器學習和統計工具（比如scikit-learn,rpy2等）Ramp提供了一個簡單的聲明性語法探索功能從而能夠快速有效地實施演算法和轉換。
19.Feature Forge
www .github .com/machinalis/featureforge
這一系列工具通過與scikit-learn兼容的API，來創建和測試機器學習功能。
這個庫程序提供了一組工具，它會讓你在許多機器學習程序使用中很受用。當你使用scikit-learn這個工具時，你會感覺到受到了很大的幫助。（雖然這只能在你有不同的演算法時起作用。）20.REP
www .github .com/yandex/rep
REP是以一種和諧、可再生的方式為指揮數據移動驅動所提供的一種環境。
它有一個統一的分類器包裝來提供各種各樣的操作，例如TMVA, Sklearn, XGBoost, uBoost等等。並且它可以在一個群體以平行的方式訓練分類器。同時它也提供了一個互動式的情節。
21.Python 學習機器樣品
www .github .com/awslabs/machine-learning-samples用亞馬遜的機器學習建造的簡單軟體收集。
22.Python-ELM
www .github .com/dclambert/Python-ELM
這是一個在Python語言下基於scikit-learn的極端學習機器的實現。
23.gensim
主題模型python實現
Scalable statistical semantics
Analyze plain-text documents for semantic structureRetrieve semantically similar documents

G. 怎樣用python構建一個卷積神經網路模型

上周末利用python簡單實現了一個卷積神經網路，只包含一個卷積層和一個maxpooling層，pooling層後面的多層神經網路採用了softmax形式的輸出。實驗輸入仍然採用MNIST圖像使用10個feature map時，卷積和pooling的結果分別如下所示。

部分源碼如下：

[python]view plain

• #coding=utf-8

• '''''

• Createdon2014年11月30日

• @author:Wangliaofan

• '''

• importnumpy

• importstruct

• importmatplotlib.pyplotasplt

• importmath

• importrandom

• import

• #test

• defsigmoid(inX):

• if1.0+numpy.exp(-inX)==0.0:

• return999999999.999999999

• return1.0/(1.0+numpy.exp(-inX))

• defdifsigmoid(inX):

• returnsigmoid(inX)*(1.0-sigmoid(inX))

• deftangenth(inX):

• return(1.0*math.exp(inX)-1.0*math.exp(-inX))/(1.0*math.exp(inX)+1.0*math.exp(-inX))

• defcnn_conv(in_image,filter_map,B,type_func='sigmoid'):

• #in_image[num,featuremap,row,col]=>in_image[Irow,Icol]

• #featuresmap[kfilter,row,col]

• #type_func['sigmoid','tangenth']

• #out_feature[kfilter,Irow-row+1,Icol-col+1]

• shape_image=numpy.shape(in_image)#[row,col]

• #print"shape_image",shape_image

• shape_filter=numpy.shape(filter_map)#[kfilter,row,col]

• ifshape_filter[1]>shape_image[0]orshape_filter[2]>shape_image[1]:

• raiseException

• shape_out=(shape_filter[0],shape_image[0]-shape_filter[1]+1,shape_image[1]-shape_filter[2]+1)

• out_feature=numpy.zeros(shape_out)

• k,m,n=numpy.shape(out_feature)

• fork_idxinrange(0,k):

• #rotate180tocalculateconv

• c_filter=numpy.rot90(filter_map[k_idx,:,:],2)

• forr_idxinrange(0,m):

• forc_idxinrange(0,n):

• #conv_temp=numpy.zeros((shape_filter[1],shape_filter[2]))

• conv_temp=numpy.dot(in_image[r_idx:r_idx+shape_filter[1],c_idx:c_idx+shape_filter[2]],c_filter)

• sum_temp=numpy.sum(conv_temp)

• iftype_func=='sigmoid':

• out_feature[k_idx,r_idx,c_idx]=sigmoid(sum_temp+B[k_idx])

• eliftype_func=='tangenth':

• out_feature[k_idx,r_idx,c_idx]=tangenth(sum_temp+B[k_idx])

• else:

• raiseException

• returnout_feature

• defcnn_maxpooling(out_feature,pooling_size=2,type_pooling="max"):

• k,row,col=numpy.shape(out_feature)

• max_index_Matirx=numpy.zeros((k,row,col))

• out_row=int(numpy.floor(row/pooling_size))

• out_col=int(numpy.floor(col/pooling_size))

• out_pooling=numpy.zeros((k,out_row,out_col))

• fork_idxinrange(0,k):

• forr_idxinrange(0,out_row):

• forc_idxinrange(0,out_col):

• temp_matrix=out_feature[k_idx,pooling_size*r_idx:pooling_size*r_idx+pooling_size,pooling_size*c_idx:pooling_size*c_idx+pooling_size]

• out_pooling[k_idx,r_idx,c_idx]=numpy.amax(temp_matrix)

• max_index=numpy.argmax(temp_matrix)

• #printmax_index

• #printmax_index/pooling_size,max_index%pooling_size

• max_index_Matirx[k_idx,pooling_size*r_idx+max_index/pooling_size,pooling_size*c_idx+max_index%pooling_size]=1

• returnout_pooling,max_index_Matirx

• defpoolwithfunc(in_pooling,W,B,type_func='sigmoid'):

• k,row,col=numpy.shape(in_pooling)

• out_pooling=numpy.zeros((k,row,col))

• fork_idxinrange(0,k):

• forr_idxinrange(0,row):

• forc_idxinrange(0,col):

• out_pooling[k_idx,r_idx,c_idx]=sigmoid(W[k_idx]*in_pooling[k_idx,r_idx,c_idx]+B[k_idx])

• returnout_pooling

• #out_featureistheoutputofconv

• defbackErrorfromPoolToConv(theta,max_index_Matirx,out_feature,pooling_size=2):

• k1,row,col=numpy.shape(out_feature)

• error_conv=numpy.zeros((k1,row,col))

• k2,theta_row,theta_col=numpy.shape(theta)

• ifk1!=k2:

• raiseException

• foridx_kinrange(0,k1):

• foridx_rowinrange(0,row):

• foridx_colinrange(0,col):

• error_conv[idx_k,idx_row,idx_col]=

• max_index_Matirx[idx_k,idx_row,idx_col]*

• float(theta[idx_k,idx_row/pooling_size,idx_col/pooling_size])*

• difsigmoid(out_feature[idx_k,idx_row,idx_col])

• returnerror_conv

• defbackErrorfromConvToInput(theta,inputImage):

• k1,row,col=numpy.shape(theta)

• #print"theta",k1,row,col

• i_row,i_col=numpy.shape(inputImage)

• ifrow>i_roworcol>i_col:

• raiseException

• filter_row=i_row-row+1

• filter_col=i_col-col+1

• detaW=numpy.zeros((k1,filter_row,filter_col))

• #thesamewithconvvalidinmatlab

• fork_idxinrange(0,k1):

• foridx_rowinrange(0,filter_row):

• foridx_colinrange(0,filter_col):

• subInputMatrix=inputImage[idx_row:idx_row+row,idx_col:idx_col+col]

• #print"subInputMatrix",numpy.shape(subInputMatrix)

• #rotatetheta180

• #printnumpy.shape(theta)

• theta_rotate=numpy.rot90(theta[k_idx,:,:],2)

• #print"theta_rotate",theta_rotate

• dotMatrix=numpy.dot(subInputMatrix,theta_rotate)

• detaW[k_idx,idx_row,idx_col]=numpy.sum(dotMatrix)

• detaB=numpy.zeros((k1,1))

• fork_idxinrange(0,k1):

• detaB[k_idx]=numpy.sum(theta[k_idx,:,:])

• returndetaW,detaB

• defloadMNISTimage(absFilePathandName,datanum=60000):

• images=open(absFilePathandName,'rb')

• buf=images.read()

• index=0

• magic,numImages,numRows,numColumns=struct.unpack_from('>IIII',buf,index)

• printmagic,numImages,numRows,numColumns

• index+=struct.calcsize('>IIII')

• ifmagic!=2051:

• raiseException

• datasize=int(784*datanum)

• datablock=">"+str(datasize)+"B"

• #nextmatrix=struct.unpack_from('>47040000B',buf,index)

• nextmatrix=struct.unpack_from(datablock,buf,index)

• nextmatrix=numpy.array(nextmatrix)/255.0

• #nextmatrix=nextmatrix.reshape(numImages,numRows,numColumns)

• #nextmatrix=nextmatrix.reshape(datanum,1,numRows*numColumns)

• nextmatrix=nextmatrix.reshape(datanum,1,numRows,numColumns)

• returnnextmatrix,numImages

• defloadMNISTlabels(absFilePathandName,datanum=60000):

• labels=open(absFilePathandName,'rb')

• buf=labels.read()

• index=0

• magic,numLabels=struct.unpack_from('>II',buf,index)

• printmagic,numLabels

• index+=struct.calcsize('>II')

• ifmagic!=2049:

• raiseException

• datablock=">"+str(datanum)+"B"

• #nextmatrix=struct.unpack_from('>60000B',buf,index)

• nextmatrix=struct.unpack_from(datablock,buf,index)

• nextmatrix=numpy.array(nextmatrix)

• returnnextmatrix,numLabels

• defsimpleCNN(numofFilter,filter_size,pooling_size=2,maxIter=1000,imageNum=500):

• decayRate=0.01

• MNISTimage,num1=loadMNISTimage("F:\train-images-idx3-ubyte",imageNum)

• printnum1

• row,col=numpy.shape(MNISTimage[0,0,:,:])

• out_Di=numofFilter*((row-filter_size+1)/pooling_size)*((col-filter_size+1)/pooling_size)

• MLP=BMNN2.MuiltilayerANN(1,[128],out_Di,10,maxIter)

• MLP.setTrainDataNum(imageNum)

• MLP.loadtrainlabel("F:\train-labels-idx1-ubyte")

• MLP.initialweights()

• #MLP.printWeightMatrix()

• rng=numpy.random.RandomState(23455)

• W_shp=(numofFilter,filter_size,filter_size)

• W_bound=numpy.sqrt(numofFilter*filter_size*filter_size)

• W_k=rng.uniform(low=-1.0/W_bound,high=1.0/W_bound,size=W_shp)

• B_shp=(numofFilter,)

• B=numpy.asarray(rng.uniform(low=-.5,high=.5,size=B_shp))

• cIter=0

• whilecIter<maxIter:

• cIter+=1

• ImageNum=random.randint(0,imageNum-1)

• conv_out_map=cnn_conv(MNISTimage[ImageNum,0,:,:],W_k,B,"sigmoid")

• out_pooling,max_index_Matrix=cnn_maxpooling(conv_out_map,2,"max")

• pool_shape=numpy.shape(out_pooling)

• MLP_input=out_pooling.reshape(1,1,out_Di)

• #printnumpy.shape(MLP_input)

• DetaW,DetaB,temperror=MLP.backwardPropogation(MLP_input,ImageNum)

• ifcIter%50==0:

• printcIter,"Temperror:",temperror

• #printnumpy.shape(MLP.Theta[MLP.Nl-2])

• #printnumpy.shape(MLP.Ztemp[0])

• #printnumpy.shape(MLP.weightMatrix[0])

• theta_pool=MLP.Theta[MLP.Nl-2]*MLP.weightMatrix[0].transpose()

• #printnumpy.shape(theta_pool)

• #print"theta_pool",theta_pool

• temp=numpy.zeros((1,1,out_Di))

• temp[0,:,:]=theta_pool

• back_theta_pool=temp.reshape(pool_shape)

• #print"back_theta_pool",numpy.shape(back_theta_pool)

• #print"back_theta_pool",back_theta_pool

• error_conv=backErrorfromPoolToConv(back_theta_pool,max_index_Matrix,conv_out_map,2)

• #print"error_conv",numpy.shape(error_conv)

• #printerror_conv

• conv_DetaW,conv_DetaB=backErrorfromConvToInput(error_conv,MNISTimage[ImageNum,0,:,:])

• #print"W_k",W_k

• #print"conv_DetaW",conv_DetaW

H. Python如何圖像識別

首先，先定位好問題是屬於圖像識別任務中的哪一類，最好上傳一張植物葉子的圖片。因為目前基於深度學習的卷積神經網路（CNN）確實在圖像識別任務中取得很好的效果，深度學習屬於機器學習，其研究的範式，或者說處理圖像的步驟大體上是一致的。

1、第一步，准備好數據集，這里是指，需要知道輸入、輸出（視任務而定，針對你這個問題，建議使用有監督模型）是什麼。你可以准備一個文件夾，裡面存放好植物葉子的圖像，而每張圖像對應一個標簽（有病/沒病，或者是多類別標簽，可能具體到哪一種病）。
具體實現中，會將數據集分為三個：訓練集（計算模型參數）、驗證集（調參，這個經常可以不需要實現劃分，在python中可以用scikit-learn中的函數解決。測試集用於驗證模型的效果，與前面兩個的區別是，模型使用訓練集和驗證集時，是同時使用了輸入數據和標簽，而在測試階段，模型是用輸入+模型參數，得到的預測與真實標簽進行對比，進而評估效果。
2、確定圖像識別的任務是什麼？

圖像識別的任務可以分為四個：圖像分類、目標檢測、語義分割、實例分割，有時候是幾個任務的結合。
圖像分類是指以圖像為輸入，輸出對該圖像內容分類的描述，可以是多分類問題，比如貓狗識別。通過足夠的訓練數據（貓和狗的照片-標簽，當然現在也有一系列的方法可以做小樣本訓練，這是細節了，這里並不敞開講），讓計算機/模型輸出這張圖片是貓或者狗，及其概率。當然，如果你的訓練數據還有其它動物，也是可以的，那就是圖像多分類問題。
目標檢測指將圖像或者視頻中的目標與不感興趣的部分區分開，判斷是否存在目標，並確定目標的具體位置。比如，想要確定這只狗所佩戴的眼睛的位置，輸入一張圖片，輸出眼睛的位置（可視化後可以講目標區域框出來）。

看到這里，應該想想植物葉子診斷疾病的問題，只需要輸入一整張植物葉子的圖片，輸出是哪種疾病，還是需要先提取葉子上某些感興趣區域（可能是病變區域），在用病變區域的特徵，對應到具體的疾病？
語義分割是當今計算機視覺領域的關鍵問題之一，宏觀上看，語義分割是一項高層次的任務。其目的是以一些原始圖像作為輸入，輸出具有突出顯示的感興趣的掩膜，其實質上是實現了像素級分類。對於輸入圖片，輸出其舌頭區域（注意可以是不規則的，甚至不連續的）。

而實例分割，可以說是在語義分割的基礎上，在像素層面給出屬於每個實例的像素。

看到這里，可以具體思考下自己的問題是對應其中的哪一類問題，或者是需要幾種任務的結合。

3、實際操作
可以先通過一個簡單的例子入手，先了解構建這一個框架需要准備什麼。手寫數字識別可以說是深度學習的入門數據集，其任務也經常作為該領域入門的案例，也可以自己在網上尋找。

I. Python人工智慧和深度學習有哪些區別

python 人工智慧
讓我們找出人工智慧到底是什麼。使人類通常執行的智力任務自動化的努力。因此，人工智慧是一個涵蓋機器學習和深度學習的通用領域，但還包括許多不涉及任何學習的方法。現代意義上的人工智慧歷史始於1950年代，當時艾倫·圖靈(Alan Turing)和達特茅斯(Dartmouth)工作坊的作品匯聚了該領域的第一批愛好者，並在其中闡述了人工智慧科學的基本原理。此外，為了成為當今世界科學的關鍵領域之一，該行業經歷了利益激增和隨後的衰退(所謂的「人工智慧冬天」)的幾個周期。值得一提的是強人工智慧和弱人工智慧的假設。強大的AI可以獨立思考和意識到自己。弱小的AI被剝奪了這種能力，僅執行一定范圍的任務(下棋，識別圖像中的貓咪或 繪制圖片，費用為432,500美元)。現有的所有AI都很薄弱，不用擔心。如今，很難想像沒有使用AI的任何類型的活動。無論您是開車，自拍照，在網上商店自己買運動鞋還是計劃假期，幾乎每個地方都有小型，薄弱但已經非常有用的人工智慧為您提供幫助。
深度學習
深度學習涉及深度神經網路。關於深度的意見可能會有所不同。一些專家認為，如果網路具有多個隱藏層，則可以將其視為深度網路;而另一些專家則認為，只有具有許多隱藏層的網路才可以視為深度網路。現在有幾種類型的神經網路正在積極使用。其中最受歡迎的是以下幾種：(1)長短期記憶(LSTM) -用於文本分類和生成，語音識別，音樂作品生成以及時間序列預測。(2)卷積神經網路(CNN) -用於圖像識別，視頻分析和自然語言處理任務。