現在隨着各種數據庫框架的盛行，在提高效率的同時也讓我們忽略了很多底層的連接過程，這篇文章是對 SQL 連接過程梳理，並涉及到了現在常用的 SQL 標準。

其實標準就是在不同的時間，制定的一些寫法或規範。

從 SQL 標準說起

在編寫 SQL 語句前，需要先了解在不同版本的規範，因為隨着版本的變化，在具體編寫 SQL 時會有所不同。對於 SQL 來說，SQL92 和 SQL99 是最常見的兩個 SQL 標準，92 和 99 對應其提出的年份。除此之外，還存在 SQL86、SQL89、SQL2003、SQL2008、SQL2011，SQL2016等等。

但對我們來說，SQL92 和 SQL99 是最常用的兩個標準，主要學習這兩個就可以了。

為了演示方便，現在數據庫中加入如下三張表：

每個學生屬於一個班級，通過班級的人數來對應班級的類型。

-- ----------------------------
DROP TABLE IF EXISTS `Student`;
CREATE TABLE `Student` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL DEFAULT '',
  `birth` varchar(20) NOT NULL DEFAULT '',
  `sex` varchar(10) NOT NULL DEFAULT '',
  `class_id` int(11) NOT NULL COMMENT '班級ID',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of Student
-- ----------------------------
INSERT INTO `Student` VALUES ('1', '胡一', '1994.1.1', '男', '1');
INSERT INTO `Student` VALUES ('3', '王阿', '1992.1.1', '女', '1');
INSERT INTO `Student` VALUES ('5', '王琦', '1993.1.2', '男', '1');
INSERT INTO `Student` VALUES ('7', '劉偉', '1998.2.2', '女', '1');
INSERT INTO `Student` VALUES ('11', '張使', '1994.1.1', '男', '3');
INSERT INTO `Student` VALUES ('13', '王阿', '1992.1.1', '女', '3');
INSERT INTO `Student` VALUES ('15', '夏琪', '1993.1.2', '男', '3');
INSERT INTO `Student` VALUES ('17', '劉表', '1998.2.2', '女', '3');
INSERT INTO `Student` VALUES ('19', '諸葛', '1994.1.1', '男', '3');
INSERT INTO `Student` VALUES ('21', '王前', '1992.1.1', '女', '3');
INSERT INTO `Student` VALUES ('23', '王意識', '1993.1.2', '男', '3');
INSERT INTO `Student` VALUES ('25', '劉等待', '1998.2.2', '女', '3');
INSERT INTO `Student` VALUES ('27', '胡是一', '1994.1.1', '男', '5');
INSERT INTO `Student` VALUES ('29', '王阿請', '1992.1.1', '女', '5');
INSERT INTO `Student` VALUES ('31', '王消息', '1993.1.2', '男', '5');
INSERT INTO `Student` VALUES ('33', '劉全', '1998.2.2', '女', '5');
INSERT INTO `Student` VALUES ('35', '胡愛', '1994.1.1', '男', '5');
INSERT INTO `Student` VALUES ('37', '王表', '1992.1.1', '女', '5');
INSERT INTO `Student` VALUES ('39', '王華', '1993.1.2', '男', '5');
INSERT INTO `Student` VALUES ('41', '劉偉以', '1998.2.2', '女', '5');
INSERT INTO `Student` VALUES ('43', '胡一彪', '1994.1.1', '男', '5');
INSERT INTO `Student` VALUES ('45', '王阿符', '1992.1.1', '女', '5');
INSERT INTO `Student` VALUES ('47', '王琦刪', '1993.1.2', '男', '5');
INSERT INTO `Student` VALUES ('49', '劉達達', '1998.2.2', '女', '5');

-- ----------------------------
-- Table structure for `Class`
-- ----------------------------
DROP TABLE IF EXISTS `Class`;
CREATE TABLE `Class` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL DEFAULT '',
  `number` int(11) NOT NULL DEFAULT '',
  `class_type_id` int(11) NOT NULL COMMENT '班級類型ID',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of Class
-- ----------------------------
INSERT INTO `Class` VALUES ('1', '1年1班', 4, '1');
INSERT INTO `Class` VALUES ('3', '1年2班', 8, '3');
INSERT INTO `Class` VALUES ('5', '1年3班', 12, '5');

CREATE TABLE `ClassType`(
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` VARCHAR(20) NOT NULL DEFAULT '',
  `minimum_number` int(11) NOT NULL DEFAULT '' COMMENT '最少的班級人數',
  `maximum_number` int(11) NOT NULL DEFAULT '' COMMENT '最多的班級人數',
  PRIMARY KEY(`id`)
);
INSERT INTO `ClassType` VALUES ('1', '小班', '1', '4');
INSERT INTO `ClassType` VALUES ('3', '中班', '5', '8');
INSERT INTO `ClassType` VALUES ('5', '大班', '9', '12');

SQL92

笛卡爾積（交叉連接）

笛卡爾積是一個數學上的概念，表示如果存在 X，Y 兩個集合，則 X，Y 的笛卡爾積記為 X * Y. 表示由 X，Y 組成有序對的所有情況。

對應在 SQL 中，就是將兩張表中的每一行進行組合。而且在連接時，可以沒有任何限制，可將沒有關聯關係的任意表進行連接。

這裏拿學生表和班級表舉例，在學生表中我們插入了20名學生的數據，課程表中插入三個班級。則學生和班級的笛卡爾結果就是將兩表的每行數據一一組合，最後就是有 24 * 3 = 72 行的結果，如下圖所示。

並且需要知道的是，下面學習的外連接，自連接，等值連接等都是在笛卡爾積的基礎上篩選得到的。

對應的 SQL92 寫法為：

select * from Student, Class;

等值連接（內連接）

等值連接就是將兩張表中都存在的列進行連接，具體來說就是 where 後面通過 = 進行篩選。

比如查詢 Student 和其所屬 Class 信息的關係：

SELECT * FROM Student as s, Class as c where s.class_id = c.id;

非等值連接

非等值連接就是將等值連接中的等號換成其他的過濾條件。

比如這裏查詢每個班級的信息以及所屬的班級類別。

SELECT * FROM Class as c, ClassType t where c.number between t.minimum_number and maximum_number;

外連接

對於 SQL92 的外連接來說，在連接時會將兩張表分為主表和從表，主表显示所有的數據，從表显示匹配到的數據，沒有匹配到的則显示 None. 用 + 表示從表的位置。

左外連接：左表是主表，右表時從表。

SELECT * FROM Student as s , Class as c where s.class_id = c.id(+);

右外連接：左表是從表，右表時主表。

SELECT * FROM Class as c, Student as s  where c.id = s.class_id(+);

注意 SQL92 中並沒有全外連接。

自連接

自連接一般用於連接本身這張表，由於常見的 DBMS 都會對自連接做一些優化，所以一般在子查詢和自連接的情況下都使用自連接。

比如想要查詢比1年1班人數多的班級：

子查詢：

SELECT * FROM Class WHERE number > (SELECT number FROM Class WHERE name="1年1班"); 

自連接：

SELECT c2.* FROM Class c1, Class c2 WHERE c1.number < c2.number and c1.name = "1年1班"; 

SQL99

交叉連接

SELECT * FROM Student CROSS JOIN Class;

還可以對多張表進行交叉連接，比如連接 Student，Class，ClassType 三張表，結果為 24 * 3 * 3 = 216 條。

相當於嵌套了三層 for 循環。

自然連接

其實就是 SQL92 中的等值連接，只不過連接的對象是具有相同列名，並且值也相同的內容。

SELECT * FROM Student NATURAL JOIN CLASS;

SELECT * FROM Student as s, Class as c where s.id = c.id;

如果想用 NATURAL JOIN 時，建議為兩表設置相同的列名，比如 Student 表中的班級列為 class_id, 則在 Class 表中，id 也應改為 class_id. 這樣連接更合理一些。

如果大家嘗試，自然連接的話，會發現查出來的結果集為空，不要奇怪，下面說一下原因：

這是因為，NATURAL JOIN 會自動連接兩張表中相同的列名，而對於 Student 和 Class 兩張表來說，id 和 name 在這兩張表都是相同的，所以既滿足 id 又滿足 name 的行是不存在的。

相當於 SQL 變成了這樣

SELECT * FROM Student as s, Class as c where s.id = c.id and s.name = c.name;

ON 連接

ON 連接其實對了 SQL92 中的等值連接和非等值連接：

等值連接：

SELECT * FROM Student as s JOIN Class as c ON s.class_id = c.id;

or

SELECT * FROM Student as s INNER JOIN Class as c ON s.class_id = c.id;

非等值連接：

SELECT * FROM Class as c JOIN ClassType t ON c.number between t.minimum_number and maximum_number;

USING 連接

和 NATURAL JOIN 很像，可以手動指定具有相同列名的列進行連接：

SELECT * FROM Student JOIN Class USING(id);

這時就解決了之前列存在重名，無法連接的情況。

外連接

左外連接: 左表是主表，右表時從表。

SELECT * FROM Student as s LEFT JOIN Class as c on s.class_id = c.id;
OR
SELECT * FROM Student as s LEFT OUTER JOIN Class as c on s.class_id = c.id;

右外連接：左表是從表，右表時主表。

SELECT * FROM Student as s RIGHT JOIN Class as c on s.class_id = c.id;
OR
SELECT * FROM Student as s RIGHT OUTER JOIN Class as c on s.class_id = c.id;

全外連接: 左外連接 + 右外的連接的合集

SELECT * FROM Student as s FULL JOIN Class as c ON s.class_id = c.id; 

MySQL 中沒有全外連接的概念。

自連接：

SELECT c2.* FROM Class c1 JOIN Class c2 ON c1.number < c2.number and c1.name = "1年1班"; 

SQL92 和 SQL99 的對比

1. SQL92 中的等值連接（內連接），非等值連接，自連接對應了 SQL99 的 ON 連接，用於篩選滿足連接條件的數據行。

2. SQL92 的笛卡爾積連接，對應了 SQL99 的交叉連接。

3. SQL92 中的外連接並不包含全外連接，而 SQL99 支持，並且將 SQL92 中 WHERE 換為 SQL99 的 ON. 這樣的好處可以更清晰的表達連接表的過程，更直觀。

   SELECT ...
   FROM table1
       JOIN table2 ON filter_condition
           JOIN table3 ON filter_condition
   

4. SQL99 多了自然連接和 USING 連接的過程，兩者的區別是是否需要顯式的指定列名。

總結

我們知道，在 SQL 中，按照年份劃分了不同的標準，其中最為常用的是 SQL-92 和 SQL-99 兩個標準。

接着，對比了 92 和 99 兩者的不同，發現 99 的標準在連接時，更加符合邏輯並且更加直觀。

最後，上一張各種連接的示意圖, 方便梳理複習：

參考

各種連接的不同

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨，RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※回頭車貨運收費標準

最近一個月項目好忙，終於擠出時間把這篇 BP 算法基本思想寫完了，公式的推導放到下一篇講吧。

一、神經網絡的代價函數

神經網絡可以看做是複雜邏輯回歸的組合，因此與其類似，我們訓練神經網絡也要定義代價函數，之後再使用梯度下降法來最小化代價函數，以此來訓練最優的權重矩陣。

1.1 從邏輯回歸出發

我們從經典的邏輯回歸代價函數引出，先來複習下：

\[J(\theta) = \frac{1}{m}\sum\limits_{i = 1}^{m}{[-{y^{(i)}}\log ({h_\theta}({x^{(i)}}))-( 1-{y^{(i)}})\log ( 1 – h_\theta({x^{(i)}}))]} + \frac{\lambda}{2m} \sum\limits_{j=1}^{n}{\theta_j^2} \]

邏輯回歸代價函數計算每個樣本的輸入與輸出的誤差，然後累加起來除以樣本數，再加上正則化項，這個我之前的博客已經寫過了：

• 從 0 開始機器學習 – 邏輯回歸原理與實戰！
• 從 0 開始機器學習 – 正則化技術原理與編程！

這裏補充一點對單變量邏輯回歸代價函數的理解，雖然這一行代價公式很長：

\[cost(i) = -{y^{(i)}}\log ({h_\theta}({x^{(i)}}))-( 1-{y^{(i)}})\log ( 1 – h_\theta({x^{(i)}})) \]

但是其實可以把它簡單的理解為輸出與輸入的方差，雖然形式上差別很大，但是可以幫助我們理解上面這個公式到底在計算什麼，就是計算輸出與輸入的方差，這樣理解就可以：

\[cost(i) = h_{\theta}(x^{(i)} – y^{(i)})^2 \]

1.2 一步步寫出神經網絡代價函數

前面講的簡單邏輯回歸的只有一個輸出變量，但是在神經網絡中輸出層可以有多個神經元，所以可以有很多種的輸出，比如 K 分類問題，神經元的輸出是一個 K 維的向量：

因此我們需要對每個維度計算預測輸出與真實標籤值的誤差，即對 K 個維度的誤差做一次求和：

\[\sum\limits_{i = 1}^{k}{[-{y_k^{(i)}}\log ({h_\theta}({x^{(i)}}))_k-( 1-{y_k^{(i)}})\log ( 1 – h_\theta({x^{(i)}})_k)]} \]

然後累加訓練集的 m 個樣本：

\[-\frac{1}{m}[\sum\limits_{i = 1}^{m}\sum\limits_{k = 1}^{k}{[-{y_k^{(i)}}\log ({h_\theta}({x^{(i)}}))_k-( 1-{y_k^{(i)}})\log ( 1 – h_\theta({x^{(i)}})_k)]}] \]

再加上所有權重矩陣元素的正則化項，注意 \(i, j\) 都是從 1 開始的，因為每一層的 \(\theta_0\) 是偏置單元，不需要對其進行正則化：

\[\frac{\lambda}{2m}\sum\limits_{i = l}^{L – 1}\sum\limits_{i = 1}^{S_l}\sum\limits_{j = 1}^{S_l + 1}(\theta_{ji}^{(l)})^2 \]

• 最內層求和：循環一個權重矩陣所有的行，行數是 \(S_l + 1\) 層激活單元數
• 中間層求和：循環一個權重矩陣所有的列，列數是 \(S_l\) 層激活單元數
• 最外層求和：循環所有的權重矩陣

這就得到了輸出層為 K 個單元神經網絡最終的代價函數：

\[J(\theta) = -\frac{1}{m}[\sum\limits_{i = 1}^{m}\sum\limits_{k = 1}^{k}{[-{y_k^{(i)}}\log ({h_\theta}({x^{(i)}}))_k-( 1-{y_k^{(i)}})\log ( 1 – h_\theta({x^{(i)}})_k)]}] + \frac{\lambda}{2m}\sum\limits_{i = l}^{L – 1}\sum\limits_{i = 1}^{S_l}\sum\limits_{j = 1}^{S_l + 1}(\theta_{ji}^{(l)})^2 \]

有了代價函數后，就可以通過反向傳播算法來訓練一個神經網絡啦！

二、神經網絡反向 BP（Back Propagation） 算法

2.1 BP 算法簡介

之前寫神經網絡基礎的時候，跟大家分享了如何用訓練好的神經網絡來預測手寫字符：從 0 開始機器學習 – 神經網絡識別手寫字符！,只不過當時我們沒有訓練網絡，而是使用已經訓練好的神經網絡的權重矩陣來進行前饋預測，那麼我們如何自己訓練神經網絡呢？

這就需要學習反向 BP 算法，這個算法可以幫助我們求出神經網絡權重矩陣中每個元素的偏導數，進而利用梯度下降法來最小化上面的代價函數，你可以聯想簡單的線性回歸算法：從 0 開始機器學習 – 一文入門多維特徵梯度下降法！，也是先求每個參數的偏導數，然後在梯度下降算法中使用求出的偏導數來迭代下降。

因此訓練神經網絡的關鍵就是：如何求出每個權重係數的偏導數？，反向 BP 就可以解決這個問題！這裏強烈建議你學習的時候完全搞懂 BP 算法的原理，最好自己獨立推導一遍公式，因為你以後學習深度學習那些複雜的網絡，不管是哪種，最終都要使用反向 BP 來訓練，這個 BP 算法是最核心的東西，面試也逃不過的，所以既然要學，就要學懂，不然就是在浪費時間。

2.2 BP 算法基本原理

我先用個例子簡單介紹下 BP 算法的基本原理和步驟，公式的推導放到下一節，反向 BP 算法顧名思義，與前饋預測方向相反：

• 計算最後一層輸出與實際標籤值的誤差，反向傳播到倒數第二層
• 計算倒數第二層的傳播誤差，反向傳播到倒數第三層
• 以此類推，一層一層地求出各層的誤差
• 直到第二層結束，因為第一層是輸入特徵，不是我們計算的，所以不需要求誤差

以下面這個 4 層的神經網絡為例：

假如我們的訓練集只有 1 個樣本 \((x^{(1)}, y^{(1)})\)，每層所有激活單元的輸出用 \(a^{(i)}\) 向量表示，每層所有激活單元的誤差用 \(\delta^{(i)}\) 向量表示，來看下反向傳播的計算步驟（公式的原理下一節講）：

1. 輸出層的誤差為預測值減去真實值：\(\delta^{(4)} = a^{(4)} – y^{(1)}\)
2. 倒數第二層的誤差為：\(\delta^{(3)} = (W^{(3)})^T \delta^{(4)} * g'(z^{(3)})\)
3. 倒數第三層的誤差為：\(\delta^{(2)} = (W^{(2)})^T \delta^{(3)} * g'(z^{(2)})\)
4. 第一層是輸入變量，不需要計算誤差

有了每層所有激活單元的誤差后，就可以計算代價函數對每個權重參數的偏導數，即每個激活單元的輸出乘以對應的誤差，這裏不考慮正則化：

\[\frac {\partial}{\partial W_{ij}^{(l)}} J (W) = a_{j}^{(l)} \delta_{i}^{(l+1)} \]

解釋下這個偏導數的計算：

• \(l\) 表示目前計算的是第幾層
• \(j\) 表示當前層中正在計算的激活單元下標（\(j\) 作為列）
• \(i\) 表示下一層誤差單元的下標（\(i\) 作為行）

這個計算過程是對一個樣本進行的，網絡的輸入是一個特徵向量，所以每層計算的誤差也是向量，但是我們的網絡輸入是特徵矩陣的話，就不能用一個個向量來表示誤差了，而是應該也將誤差向量組成誤差矩陣，因為特徵矩陣就是多個樣本，每個樣本都做一個反向傳播，就會計算誤差，所以我們每次都把一個樣本計算的誤差累加到誤差矩陣中：

\[\Delta_{ij}^{(l)} = \Delta_{ij}^{(l)} + a_{j}^{(l)} \delta_{i}^{(l+1)} \]

然後，我們需要除以樣本總數 \(m\)，因為上面的誤差是累加了所有 \(m\) 個訓練樣本得到的，並且我們還需要考慮加上正則化防止過擬合，注意對偏置單元不需要正則化，這點已經提過好多次了：

• 非偏置單元正則化后的偏導數 \(j \neq 0\)：

\[D_{ij}^{(l)} = \frac {1}{m}\Delta_{ij}^{(l)}+\lambda W_{ij}^{(l)} \]

• 偏置單元正則化后的偏導數 \(j = 0\)：

\[D_{ij}^{(l)} = \frac{1}{m}\Delta_{ij}^{(l)} \]

最後計算的所有偏導數就放在誤差矩陣中：

\[\frac {\partial}{\partial W_{ij}^{(l)}} J (W) = D_{ij}^{(l)} \]

這樣我們就求出了每個權重參數的偏導數，再回想之前的梯度下降法，我們有了偏導數計算方法后，直接送到梯度下降法中進行迭代就可以最小化代價函數了，比如我在 Python 中把上面的邏輯寫成一個正則化梯度計算的函數 regularized_gradient，然後再用 scipy.optimize 等優化庫直接最小化文章開頭提出的神經網絡代價函數，以此來使用反向 BP 算法訓練一個神經網絡：

import scipy.optimize as opt

res = opt.minimize(fun = 神經網絡代價函數,
                       x0 = init_theta,
                       args = (X, y, 1),
                       method = 'TNC',
                       jac = regularized_gradient,
                       options = {'maxiter': 400})

所以神經網絡反向 BP 算法關鍵就是理解每個權重參數偏導數的計算步驟和方法！關於偏導數計算公式的詳細推導過程，我打算在下一篇文章中單獨分享，本次就不帶大家一步步推導了，否則內容太多，先把基本步驟搞清楚，後面推導公式就容易理解。

2.3 反向 BP 算法的直觀理解

之前學習前饋預測時，我們知道一個激活單元是輸入是上一層所有激活單元的輸出與權重的加權和（包含偏置），計算方向從左到右，計算的是每個激活單元的輸出，看圖：

其實反向 BP 算法也是做類似的計算，一個激活單元誤差的輸入是后一層所有誤差與權重的加權和（可能不包含偏置），只不過這裏計算的反向是從右向左，計算的是每個激活單元的誤差，對比看圖：

你只需要把單個神經元的前饋預測和反向 BP 的計算步驟搞清楚就可以基本理解反向 BP 的基本過程，因為所有的參數都是這樣做的。

三、神經網絡編程細節

3.1 隨機初始化

每種優化算法都需要初始化參數，之前的線性回歸初始化參數為 0 是沒問題的，但是如果把神經網絡的初始參數都設置為 0，就會有問題，因為第二層的輸入是要用到權重與激活單元輸出的乘積：

• 如果權重都是 0，則每層網絡的輸出都是 0
• 如果權重都是相同的常數 \(a\)，則每層網絡的輸出也都相同，只是不為 0

所以為了在神經網絡中避免以上的問題，我們採用隨機初始化，把所有的參數初始化為 \([-\epsilon, \epsilon]\) 之間的隨機值，比如初始化一個 10 X 11 的權重參數矩陣：

\[initheta = rand(10, 11) * (2 * \epsilon) – \epsilon \]

3.2 矩陣 <-> 向量

注意上面優化庫的輸入 X0 = init_theta 是一個向量，而我們的神經網絡每 2 層之間就有一個權重矩陣，所以為了把權重矩陣作為優化庫的輸入，我們必須要把所有的權重參數都組合到一個向量中，也就是實現一個把矩陣組合到向量的功能，但是優化庫的輸出也是一個包含所有權重參數的向量，我們拿到向量后還需要把它轉換為每 2 層之間的權重矩陣，這樣才能進行前饋預測：

• 訓練前：初始多個權重矩陣 -> 一個初始向量
• 訓練后：一個最優向量 -> 多個最優權重矩陣

3.3 梯度校驗

梯度校驗是用來檢驗我們的 BP 算法計算的偏導數是否和真實的偏導數存在較大誤差，計算以下 2 個偏導數向量的誤差：

• 反向 BP 算法計算的偏導數
• 利用導數定義計算的偏導數

對於單個參數，在一點 \(\theta\) 處的導數可由 \([\theta – \epsilon, \theta + \epsilon]\) 表示，這也是導數定義的一種：

\[grad = \frac{J(\theta + \epsilon) – J(\theta – \epsilon)}{2 \epsilon} \]

如圖：

但是我們的神經網絡代價函數有很多參數，當我們把參數矩陣轉為向量后，可以對向量里的每個參數進行梯度檢驗，只需要分別用定義求偏導數即可，比如檢驗 \(\theta_1\)：

\[\frac {\partial J}{\partial \theta_1} = \frac {J (\theta_1 + \varepsilon_1, \theta_2, \theta_3 … \theta_n ) – J(\theta_1 – \varepsilon_1, \theta_2, \theta_3 … \theta_n)}{2 \varepsilon} \]

以此類推，檢驗 \(\theta_n\)：

\[\frac {\partial J}{\partial \theta_n} = \frac {J (\theta_1, \theta_2, \theta_3 … \theta_n + \varepsilon_n) – J(\theta_1, \theta_2, \theta_3 … \theta_n – \varepsilon_n)}{2 \varepsilon} \]

求出導數定義的偏導數后，與 BP 算法計算的偏導數計算誤差，在誤差範圍內認為 BP 算法計算的偏導數（D_vec）是正確的，梯度檢驗的偽代碼如下：

for i = 1 : n
  theta_plus = theta
  theta_plus[i] = theta_plus + epsilon
  
  theta_minu = theta
  theta_minu[i] = theta_minu - epsilon
  
  grad = (J(theta_plus) - J(theta_minu)) / (2 * epsilon)
end

check 誤差: grad 是否約等於 D_vec

注意一點：梯度檢驗通常速度很慢，在訓練神經網絡前先別進行檢驗！

今天就到這，溜了溜了，下篇文章見：）

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨，RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※回頭車貨運收費標準

什麼是過擬合

過擬合就是在訓練集上表現得非常好，在測試集上表現得不好。也就是我們俗稱的泛化能力弱。

過擬合無法避免，只能緩解，那麼如何緩解呢？方法太多了。這篇文章一一介紹。

數據集增強Augmentation

圖像上，翻轉，平移，縮放，旋轉，鏡像，增強對比度，增強亮度等諸多方式。
我在下面的內容中介紹了圖像處理的圖像增強的方法：
【預處理庫函數】albumentations庫的簡單了解和使用

Early Stopping

訓練模型的時候，訓練誤差往往是不斷下降的，但是驗證數據集的誤差，是先下降後上升。 兩個數據集的誤差出現分歧的時候，說明模型開始過擬合了。所以Early Stopping就是當驗證數據集的誤差不在下降的時候，結束訓練，保存模型參數。

正則化regularization

L1正則：模型中只有少部分特徵對模型的泛化能力有貢獻，所以L1就是限制模型中非零參數的數量。讓大部分的模型參數都是0，只有真正對泛化能力其作用的參數才是非零的。

L2正則：我們希望模型找到的極小值是平坦的，為什麼呢？

圖中表示的意思，就是平坦的極小值，可以有更多的容忍，容忍什麼呢？容忍訓練數據集和測試數據集之前的分佈偏差。現在，如果模型的某些參數特別大，那麼就算輸入的樣本只有很小的區別，但是經過特別大的參數之後，模型給出的結果很可能是非常不同的。這就是太陡峭。所以L2正則就是限制模型參數的大小。參數的平方的和作為損失的一部分，當參數數值越大，那麼梯度下降的損失越大，就會強迫參數變小。

這裡有兩幅圖：

這一幅圖體現的是假設只有兩個參數的情況下，增加L1正則的情況。圓圈圈體現的是損失等值線，方框是L1正則的損失。假設沒有L1正則，那麼參數應該收斂到最小的那個圓圈中的。但是因為增加了L1正則，所以需要權衡兩個部分的損失，然後找到接觸的交點位置。因為圓形和矩形在矩形的頂點相交的可能性大，而矩形的頂點就是某一個參數為0的情況。所以L1正則會讓模型參數有更大的可能性為0.
【在更多參數的模型中，會有更多的頂點。不過二維圖像就畫不出來了】

這個是L2正則的示意圖。L2正則式一個原型因為是參數的平方和。相比L1的（0,1）這樣的交點，L2更希望每一個參數都普遍較小，不希望某一個參數特別大。

Dropout

這個就是神經網絡中，在全連接網絡中經常用到的。

在每一個Batch數據訓練的時候，Dropout層按照概率P隨機讓一些神經元失活，然後保留下來的神經元的參數被更新。dropout是只有在訓練的時候才使用的，在測試的時候並不適用。

我個人理解的dropout其實就相當於一個多模型融合的過程。因為每一次都會失活一部分的神經元，所以每一次的模型都是不那麼一樣的，相當於不同的模型吧。

增加噪音

輸入中增加噪音

輸入中有噪音\(\epsilon\)，那麼輸出中就會有一個類似於\(\epsilon \omega\),這樣的損失項。 從而限制權值的大小。

當然這樣也可以增加模型對輸入的容忍度，我覺得也可以理解為一種數據增強。 去噪自編碼器DAE就是利用這樣的方法的。

權值中加噪音

這個用的不多，在初始化網絡的時候，用0均值的高斯分佈作為參數的初始化。

集成

集成主要是bagging，boosting，之前說的dropout我覺得也可以算作集成的方法

bagging

將數據集抽取一部分，比如抽取70%的樣本，然後用這些樣本去訓練一個模型。然後再從數據集中抽取70%的樣本，再訓練一個新的。典型的就是隨機森林。
【神經網絡因為訓練速度的問題，所以一般不用這樣的方法。決策樹lgb啥的可以用】

boosting

訓練複雜神經網絡比較慢，所以可以通過訓練多個簡單的分類器，然後加權平均每一個分類器的輸出。這就是Boost的思想。【這句話給我背下來！】

之後整理一下Adaboost和XGBoost的這些算法。

其他

• 限制網絡的層數和複雜度

**END**

喜歡的話請關注我們的微信公眾號~《你好世界煉丹師》或者知乎【你好世界煉丹師】。

• 公眾號主要講統計學，數據科學，機器學習，深度學習，以及一些參加Kaggle競賽的經驗。
• 公眾號內容建議作為課後的一些相關知識的補充，飯後甜點。
• 此外，為了不過多打擾，公眾號每周推送一次，每次4~6篇精選文章。

微信搜索公眾號：你好世界煉丹師。期待您的關注。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨，RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※回頭車貨運收費標準

程泰16日參加宏遠證券所舉辦自動化產業投資論壇，對於2017年營運展望，程泰表示，目前母公司程泰集團在手訂單已回升至5億多元，且未含3月台北國際工具機展部分，同時在中國大陸訂單約有2-3億元，整體而言，目前整體訂單能見度看到第二季底。程泰集團董事長楊德華則表示，集團整體在手訂單規模約22億至23億元，至於3月台北國際工具機展接單規模約在3億至5億元。

程泰也指出，公司業務以車床為主，由於波音預期未來20年全球航太市場規模將達180兆元，預估民航機需求約3.8萬架，加上政府要推國機國造，因此未來也會聚焦在航太產業。此外，在電動車布局方面，程泰打入美國特斯拉電動車Model 3供應鏈，於台中大里工業區建立代工基地，預計今年底起，每月將出貨減速齒輪箱的齒輪傳動軸前端車銑磨6萬套。

程泰集團旗下包括程泰及亞崴兩工具機廠，亞崴表示，農曆年後，台灣航太及汽車零組件業開始投資擴廠，加上推進國機國造及航太零件國產化，預期今年台灣市場會有不錯表現，目前台灣地區在手訂單14億元，大陸吳江及嘉興廠在手訂單3-4億元，兩岸合併在手訂單約18億元，訂單能見度看到7月；在產能布局方面，嘉義大埔美一期新廠預計今年底完工，大陸吳江廠亦規劃最快於今年底興建二期廠。

（本文內容由授權使用。圖片出處：Tesla）

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨，RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※回頭車貨運收費標準

前言

在使用Spring和SpringMVC的老版本進行開發時，我們需要配置很多的xml文件，非常的繁瑣，總是讓用戶自行選擇配置也是非常不好的。基於約定大於配置的規定，Spring提供了很多註解幫助我們簡化了大量的xml配置；但是在使用SpringMVC時，我們還會使用到WEB-INF/web.xml，但實際上我們是完全可以使用Java類來取代xml配置的，這也是後來SpringBoott的實現原理。本篇就來看看Spring是如何實現完全的零XML配置。

正文

先來看一下原始的web.xml配置：

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
      <!--加載spring配置-->
      classpath:spring.xml
    </param-value>
  </context-param>
  <context-param>
    <param-name>webAppRootKey</param-name>
    <param-value>ServicePlatform.root</param-value>
  </context-param>

  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    <!--<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>-->
  </listener>

  <servlet>
    <servlet-name>spring-dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <!--springmvc的配置文件-->
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:spring-dispatcher.xml</param-value>
    </init-param>
    <load-on-startup>0</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>spring-dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

這裏各個配置的作用簡單說下，context-param是加載我們主的sping.xml配置，比如一些bean的配置和開啟註解掃描等；listener是配置監聽器，Tomcat啟動會觸發監聽器調用；servlet則是配置我們自定義的Servlet實現，比如DispatcherServlet。還有其它很多配置就不一一說明了，在這裏主要看到記住context-param和servlet配置，這是SpringIOC父子容器的體現。在之前的I文章中講過IOC容器是以父子關係組織的，但估計大部分人都不能理解，除了看到複雜的繼承體系，並沒有看到父容器作用的體現，稍後來分析。
了解了配置，我們就需要思考如何替換掉這些繁瑣的配置。實際上Tomcat提供了一個規範，有一個ServletContainerInitializer接口：

public interface ServletContainerInitializer {
    void onStartup(Set<Class<?>> var1, ServletContext var2) throws ServletException;
}

Tomcat啟動時會調用該接口實現類的onStartup方法，這個方法有兩個參數，第二個不用說，主要是第一個參數什麼？從哪裡來？另外我們自定義的實現類又怎麼讓Tomcat調用呢？
首先解答最後一個問題，這裏也是利用SPI來實現的，因此我們實現了該接口后，還需要在META-INF.services下配置。其次，這裏傳入的第一個參數也是我們自定義的擴展接口的實現類，我們可以通過我們自定義的接口實現很多需要在啟動時做的事，比如加載Servlet，但是Tomcat又是怎麼知道我們自定義的接口是哪個呢？這就需要用到@HandlesTypes註解，該註解就是標註在ServletContainerInitializer的實現類上，其值就是我們擴展的接口，這樣Tomcat就知道需要傳入哪個接口實現類到這個onStartup方法了。來看一個簡單的實現：

@HandlesTypes(LoadServlet.class)
public class MyServletContainerInitializer implements ServletContainerInitializer {
    @Override
    public void onStartup(Set<Class<?>> set, ServletContext servletContext) throws ServletException {
        Iterator var4;
        if (set != null) {
            var4 = set.iterator();
            while (var4.hasNext()) {
                Class<?> clazz = (Class<?>) var4.next();
                if (!clazz.isInterface() && !Modifier.isAbstract(clazz.getModifiers()) && LoadServlet.class.isAssignableFrom(clazz)) {
                    try {
                        ((LoadServlet) clazz.newInstance()).loadOnstarp(servletContext);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

public interface LoadServlet {

    void loadOnstarp(ServletContext servletContext);
}

public class LoadServletImpl implements LoadServlet {
    @Override
    public void loadOnstarp(ServletContext servletContext) {
        ServletRegistration.Dynamic initServlet = servletContext.addServlet("initServlet", "org.springframework.web.servlet.DispatcherServlet");
        initServlet.setLoadOnStartup(1);
        initServlet.addMapping("/init");
	}
}

這就是Tomcat給我們提供的規範，通過這個規範我們就能實現Spring的零xml配置啟動，直接來看Spring是如何做的。
根據上面所說我們可以在spring-web工程下找到META-INF/services/javax.servlet.ServletContainerInitializer配置：

@HandlesTypes(WebApplicationInitializer.class)
public class SpringServletContainerInitializer implements ServletContainerInitializer {
	@Override
	public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
			throws ServletException {

		List<WebApplicationInitializer> initializers = new LinkedList<>();

		if (webAppInitializerClasses != null) {
			for (Class<?> waiClass : webAppInitializerClasses) {
				// Be defensive: Some servlet containers provide us with invalid classes,
				// no matter what @HandlesTypes says...
				if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
						WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
					try {
						initializers.add((WebApplicationInitializer)
								ReflectionUtils.accessibleConstructor(waiClass).newInstance());
					}
					catch (Throwable ex) {
						throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
					}
				}
			}
		}

		if (initializers.isEmpty()) {
			servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
			return;
		}

		servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
		AnnotationAwareOrderComparator.sort(initializers);
		for (WebApplicationInitializer initializer : initializers) {
			initializer.onStartup(servletContext);
		}
	}

}

核心的實現就是WebApplicationInitializer，先看看其繼承體系

AbstractReactiveWebInitializer不用管，主要看另外一邊，但是都是抽象類，也就是說真的實例也是由我們自己實現，但需要我們實現什麼呢？我們一般直接繼承AbstractAnnotationConfigDispatcherServletInitializer類，有四個抽象方法需要我們實現：

    //父容器
    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class<?>[]{SpringContainer.class};
    }

    //SpringMVC配置子容器
    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class<?>[]{MvcContainer.class};
    }

    //獲取DispatcherServlet的映射信息
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

	// filter配置
    @Override
    protected Filter[] getServletFilters() {
        MyFilter myFilter = new MyFilter();
        CorsFilter corsFilter = new CorsFilter();
        return new Filter[]{myFilter,corsFilter};
    }

這裏主要注意getRootConfigClasses和getServletConfigClasses方法，分別加載父、子容器：

@ComponentScan(value = "com.dark",excludeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
})
public class SpringContainer {
}

@ComponentScan(value = "com.dark",includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class})
},useDefaultFilters = false)
public class MvcContainer {
}

看到這兩個類上的註解應該不陌生了吧，父容器掃描裝載了所有不帶@Controller註解的類，子容器則相反，但需要對象時首先從當前容器中找，如果沒有則從父容器中獲取，為什麼要這麼設計呢？直接放到一個容器中不行么？先思考下， 稍後解答。
回到onStartup方法中，直接回調用到AbstractDispatcherServletInitializer類：

	public void onStartup(ServletContext servletContext) throws ServletException {
		super.onStartup(servletContext);
		//註冊DispatcherServlet
		registerDispatcherServlet(servletContext);
	}

先是調用父類：

	public void onStartup(ServletContext servletContext) throws ServletException {
		registerContextLoaderListener(servletContext);
	}

	protected void registerContextLoaderListener(ServletContext servletContext) {

		//創建spring上下文，註冊了SpringContainer
		WebApplicationContext rootAppContext = createRootApplicationContext();
		if (rootAppContext != null) {
			//創建監聽器
			ContextLoaderListener listener = new ContextLoaderListener(rootAppContext);
			listener.setContextInitializers(getRootApplicationContextInitializers());
			servletContext.addListener(listener);
		}
	}

然後調用createRootApplicationContext創建父容器：

	protected WebApplicationContext createRootApplicationContext() {
		Class<?>[] configClasses = getRootConfigClasses();
		if (!ObjectUtils.isEmpty(configClasses)) {
			AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
			context.register(configClasses);
			return context;
		}
		else {
			return null;
		}
	}

可以看到就是創建了一個AnnotationConfigWebApplicationContext對象，並將我們的配置類SpringContainer註冊了進去。接着創建Tomcat啟動加載監聽器ContextLoaderListener，該監聽器有一個contextInitialized方法，會在Tomcat啟動時調用。

	public void contextInitialized(ServletContextEvent event) {
		initWebApplicationContext(event.getServletContext());
	}

	 */
	public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
		long startTime = System.currentTimeMillis();
		try {
			// Store context in local instance variable, to guarantee that
			// it is available on ServletContext shutdown.
			if (this.context == null) {
				this.context = createWebApplicationContext(servletContext);
			}
			if (this.context instanceof ConfigurableWebApplicationContext) {
				ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
				if (!cwac.isActive()) {
					// The context has not yet been refreshed -> provide services such as
					// setting the parent context, setting the application context id, etc
					if (cwac.getParent() == null) {
						// The context instance was injected without an explicit parent ->
						// determine parent for root web application context, if any.
						ApplicationContext parent = loadParentContext(servletContext);
						cwac.setParent(parent);
					}
					configureAndRefreshWebApplicationContext(cwac, servletContext);
				}
			}
			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

			ClassLoader ccl = Thread.currentThread().getContextClassLoader();
			if (ccl == ContextLoader.class.getClassLoader()) {
				currentContext = this.context;
			}
			else if (ccl != null) {
				currentContextPerThread.put(ccl, this.context);
			}

			return this.context;
		}
	}

可以看到就是去初始化容器，這個和之前分析xml解析是一樣的，主要注意這裏封裝了ServletContext對象，並將父容器設置到了該對象中。
父容器創建完成后自然就是子容器的創建，來到registerDispatcherServlet方法：

	protected void registerDispatcherServlet(ServletContext servletContext) {
		String servletName = getServletName();
		Assert.hasLength(servletName, "getServletName() must not return null or empty");

		//創建springmvc的上下文，註冊了MvcContainer類
		WebApplicationContext servletAppContext = createServletApplicationContext();
		Assert.notNull(servletAppContext, "createServletApplicationContext() must not return null");

		//創建DispatcherServlet
		FrameworkServlet dispatcherServlet = createDispatcherServlet(servletAppContext);
		Assert.notNull(dispatcherServlet, "createDispatcherServlet(WebApplicationContext) must not return null");
		dispatcherServlet.setContextInitializers(getServletApplicationContextInitializers());

		ServletRegistration.Dynamic registration = servletContext.addServlet(servletName, dispatcherServlet);
		if (registration == null) {
			throw new IllegalStateException("Failed to register servlet with name '" + servletName + "'. " +
					"Check if there is another servlet registered under the same name.");
		}

		/*
		* 如果該元素的值為負數或者沒有設置，則容器會當Servlet被請求時再加載。
			如果值為正整數或者0時，表示容器在應用啟動時就加載並初始化這個servlet，
			值越小，servlet的優先級越高，就越先被加載
		* */
		registration.setLoadOnStartup(1);
		registration.addMapping(getServletMappings());
		registration.setAsyncSupported(isAsyncSupported());

		Filter[] filters = getServletFilters();
		if (!ObjectUtils.isEmpty(filters)) {
			for (Filter filter : filters) {
				registerServletFilter(servletContext, filter);
			}
		}

		customizeRegistration(registration);
	}

	protected WebApplicationContext createServletApplicationContext() {
		AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
		Class<?>[] configClasses = getServletConfigClasses();
		if (!ObjectUtils.isEmpty(configClasses)) {
			context.register(configClasses);
		}
		return context;
	}

這裏也是創建了一個AnnotationConfigWebApplicationContext對象，不同的只是這裏註冊的配置類就是我們的Servlet配置了。然後創建了DispatcherServlet對象，並將上下文對象設置了進去。看到這你可能會疑惑，既然父子容器創建的都是相同類的對象，何來的父子容器之說？別急，這個在初始化該上文時就明白了。但是這裏的初始化入口在哪呢？沒有看到任何監聽器的創建和調用。實際上這裏的上下文對象初始化是在Servlet初始化時實現的，即init方法，直接來到HttpServletBean的init方法（分析SpringMVC源碼時講過）：

	public final void init() throws ServletException {
		...省略
		
		// Let subclasses do whatever initialization they like.
		initServletBean();
	}

	protected final void initServletBean() throws ServletException {
		try {
			this.webApplicationContext = initWebApplicationContext();
			initFrameworkServlet();
		}
	}

	protected WebApplicationContext initWebApplicationContext() {
		//這裡會從servletContext中獲取到父容器，就是通過監聽器加載的容器
		WebApplicationContext rootContext =
				WebApplicationContextUtils.getWebApplicationContext(getServletContext());
		WebApplicationContext wac = null;

		if (this.webApplicationContext != null) {
			// A context instance was injected at construction time -> use it
			wac = this.webApplicationContext;
			if (wac instanceof ConfigurableWebApplicationContext) {
				ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
				if (!cwac.isActive()) {
					if (cwac.getParent() == null) {
						cwac.setParent(rootContext);
					}
					//容器加載
					configureAndRefreshWebApplicationContext(cwac);
				}
			}
		}
		if (wac == null) {
			wac = findWebApplicationContext();
		}
		if (wac == null) {
			wac = createWebApplicationContext(rootContext);
		}

		if (!this.refreshEventReceived) {
			synchronized (this.onRefreshMonitor) {
				onRefresh(wac);
			}
		}

		if (this.publishContext) {
			// Publish the context as a servlet context attribute.
			String attrName = getServletContextAttributeName();
			getServletContext().setAttribute(attrName, wac);
		}

		return wac;
	}

看到這裏想你也應該明白了，首先從ServletContext中拿到父容器，然後設置到當前容器的parent中，實現了父子容器的組織，而這樣設計好處我想也是很清楚的，子容器目前裝載的都是MVC的配置和Bean，簡單點說就是Controller，父容器中都是Service，Controller是依賴於Service的，如果不構建這樣的層級關係並優先實例化父容器，你怎麼實現Controller層的依賴注入成功呢？

總結

本篇結合之前的文章，分析了SpringMVC零XML配置的實現原理，也補充了之前未分析到父子容器關係，讓我們能從細節上更加全面的理解SpringIOC的實現原理，相信看完本篇對於SpringBoot的實現你也會有自己的想法。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨，RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※回頭車貨運收費標準

近年來，在電子商務快速發展的強勢需求拉動下，中國電商物流繼續保持快速增長。在環境壓力較大的當下，物流行業推行新能源汽車也成了改善環境，治理霧霾的一個重要手段。

在新能源物流車形勢一片大好的情況下，新能源客車產品在細分市場銷量第二把交椅的南京金龍自然也不會錯過這一片藍海。據瞭解，南京金龍將於2017上海國際新能源汽車產業博覽會上推出四款新品純電動物流車。展會由振威展覽股份、中國土木工程學會城市公共交通學會、廣東省新能源汽車產業協會、廣東省充電設施協會及充電設施線上網聯合舉辦，將於2017年8月23-25日在上海新國際博覽中心舉行。

據瞭解，本次南京金龍四款純電動物流車型分別為開沃D07、開沃D09、開沃D10和開沃D11。此四款物流車涵蓋3.9-5.9米的中小型物流車，且秉承其一貫的強勁續航能力，滿載續航均在220-260公里，是名副其實的續航之王。其中開沃D07為微型純電動物流車，主要用於城市內的快遞派送。作為“最後一公里”快遞配送專家，其載貨空間達3.4立方米，載貨量可達600KG，完美滿足市網點到客戶的快遞配送。開沃D09、D10為輕型純電動物流車，載貨空間分別在6立方米和8立方米，載重分別為750kg和1000kg，主要用作城市間的物流配送“貨的”。

去年，南京金龍就推出了素有“快遞王”之稱的開沃E7，“物流王”開沃D11，早已以其380公里左右的高續航、1.55噸的高載重、12.3個立方的高容量等特點,4小時繞北京五環三圈贏得了新能源物流車界的良好口碑。D11作為城市大空間長續航的物流王更是經受市場考驗超過3年、以好品質得到客戶認可和擁護的車型，輕鬆勝任城市間的物流運輸。

3月1日，工信部官網正式公佈了《新能源汽車推廣應用推薦車型目錄（2017年第2批）》主要車型及參數。此次發佈的目錄涉及新能源乘用車、新能源客車及新能源專用車共有40家企業201款車型進入目錄。其中，南京金龍開沃牌NJL5040XXYBEV1純電動廂式運輸車入圍本次目錄。

資料顯示，2016年純電動物流車產量達5.78萬輛，且2017年剛開始，工信部就給電動物流車行業一個驚喜。首批新能源汽車推薦目錄發佈，以電動物流車為代表的專用車型共有36款，占總比19%。“新能源物流車正成為新能源商用車發展的一大亮點。”全國乘聯會秘書長崔東樹也指出，新能源物流車使用費用低，維（護）修簡單，從國家政策的扶持以及城市空氣污染的角度來看，新能源物流車急劇增長是必然的，也是長期的發展趨勢。

據不完全統計，北京、上海、廣東、天津等37省市出臺的新能源汽車政策裡都有提及純電動物流車的相關政策。隨著政策的明朗，行業逐漸趨於理性，純電動物流車市場迎來健康發展，其也將迎來真正的發展元年。業界普遍認為，2017年電動物流車行業預計將實現10萬輛左右的銷量，同比增速超過100%。

南京金龍市場負責人表示，本次展會的召開是一個很好的契機，南京金龍開沃純電動物流車憑藉靈活多變的空間及穩定的滿負荷續航里程，將極大地改變我國新能源物流車產業發展格局。未來，南京金龍憑藉產品技術優勢，不斷開拓物流、快遞行業需求，為全面實現“零排放物流”的行業大計而持續努力。

組委會聯繫方式：+86 20-83953286
連絡人：黃俊鵬
官方微信公眾號：nevechina

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨，RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※回頭車貨運收費標準