圖演算法安全邊

⑴ 圖演算法怎麼做啊

查看數據結構的書吧

⑵ [圖像演算法]-Faster RCNN詳解

paper： Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks
Tensorflow-faster r-cnn github: Tensorflow Faster RCNN for Object Detection

faster rcnn是何凱明等大神在2015年提出目標檢測演算法，該演算法在2015年的ILSVRV和COCO競賽中獲得多項第一。該演算法在fast rcnn基礎上提出了RPN候選框生成演算法，使得目標檢測速度大大提高。

(1)image input；
(2)利用selective search 演算法在圖像中從上到下提取2000個左右的Region Proposal；
(3)將每個Region Proposal縮放(warp)成227*227的大小並輸入到CNN，將CNN的fc7層的輸出作為特徵；
(4)將每個Region Proposal提取的CNN特徵輸入到SVM進行分類；
(5)對於SVM分好類的Region Proposal做邊框回歸，用Bounding box回歸值校正原來的建議窗口，生成預測窗口坐標.
缺陷:
(1) 訓練分為多個階段，步驟繁瑣：微調網路+訓練SVM+訓練邊框回歸器；
(2) 訓練耗時，佔用磁碟空間大；5000張圖像產生幾百G的特徵文件；
(3) 速度慢：使用GPU，VGG16模型處理一張圖像需要47s；
(4) 測試速度慢：每個候選區域需要運行整個前向CNN計算；
(5) SVM和回歸是事後操作，在SVM和回歸過程中CNN特徵沒有被學習更新.

(1)image input；
(2)利用selective search 演算法在圖像中從上到下提取2000個左右的建議窗口(Region Proposal)；
(3)將整張圖片輸入CNN，進行特徵提取；
(4)把建議窗口映射到CNN的最後一層卷積feature map上；
(5)通過RoI pooling層使每個建議窗口生成固定尺寸的feature map；
(6)利用Softmax Loss(探測分類概率) 和Smooth L1 Loss(探測邊框回歸)對分類概率和邊框回歸(Bounding box regression)聯合訓練.

相比R-CNN，主要兩處不同:
(1)最後一層卷積層後加了一個ROI pooling layer；
(2)損失函數使用了多任務損失函數(multi-task loss)，將邊框回歸直接加入到CNN網路中訓練
改進:
(1) 測試時速度慢：R-CNN把一張圖像分解成大量的建議框，每個建議框拉伸形成的圖像都會單獨通過CNN提取特徵.實際上這些建議框之間大量重疊，特徵值之間完全可以共享，造成了運算能力的浪費.
FAST-RCNN將整張圖像歸一化後直接送入CNN，在最後的卷積層輸出的feature map上，加入建議框信息，使得在此之前的CNN運算得以共享.
(2) 訓練時速度慢：R-CNN在訓練時，是在採用SVM分類之前，把通過CNN提取的特徵存儲在硬碟上.這種方法造成了訓練性能低下，因為在硬碟上大量的讀寫數據會造成訓練速度緩慢.
FAST-RCNN在訓練時，只需要將一張圖像送入網路，每張圖像一次性地提取CNN特徵和建議區域，訓練數據在GPU內存里直接進Loss層，這樣候選區域的前幾層特徵不需要再重復計算且不再需要把大量數據存儲在硬碟上.
(3) 訓練所需空間大：R-CNN中獨立的SVM分類器和回歸器需要大量特徵作為訓練樣本，需要大量的硬碟空間.FAST-RCNN把類別判斷和位置回歸統一用深度網路實現，不再需要額外存儲.
(4) 由於ROI pooling的提出，不需要再input進行Corp和wrap操作，避免像素的損失，巧妙解決了尺度縮放的問題.

(1)輸入測試圖像；
(2)將整張圖片輸入CNN，進行特徵提取；
(3)用RPN先生成一堆Anchor box，對其進行裁剪過濾後通過softmax判斷anchors屬於前景(foreground)或者後景(background)，即是物體or不是物體，所以這是一個二分類；同時，另一分支bounding box regression修正anchor box，形成較精確的proposal（註：這里的較精確是相對於後面全連接層的再一次box regression而言）
(4)把建議窗口映射到CNN的最後一層卷積feature map上；
(5)通過RoI pooling層使每個RoI生成固定尺寸的feature map；
(6)利用Softmax Loss(探測分類概率) 和Smooth L1 Loss(探測邊框回歸)對分類概率和邊框回歸(Bounding box regression)聯合訓練.

相比FASTER-RCNN，主要兩處不同:
(1)使用RPN(Region Proposal Network)代替原來的Selective Search方法產生建議窗口；
(2)產生建議窗口的CNN和目標檢測的CNN共享

改進:
(1) 如何高效快速產生建議框？
FASTER-RCNN創造性地採用卷積網路自行產生建議框，並且和目標檢測網路共享卷積網路，使得建議框數目從原有的約2000個減少為300個，且建議框的質量也有本質的提高.

從上面的三張圖可以看出，Faster R CNN由下面幾部分組成：
1.數據集，image input
2.卷積層CNN等基礎網路，提取特徵得到feature map
3-1.RPN層，再在經過卷積層提取到的feature map上用一個3x3的slide window，去遍歷整個feature map,在遍歷過程中每個window中心按rate，scale（1:2,1:1,2:1）生成9個anchors，然後再利用全連接對每個anchors做二分類（是前景還是背景）和初步bbox regression，最後輸出比較精確的300個ROIs。
3-2.把經過卷積層feature map用ROI pooling固定全連接層的輸入維度。
4.然後把經過RPN輸出的rois映射到ROIpooling的feature map上進行bbox回歸和分類。

SPP-Net是出自論文《Spatial Pyramid Pooling in Deep Convolutional Networks for Visual Recognition》
由於一般的網路結構中都伴隨全連接層，全連接層的參數就和輸入圖像大小有關，因為它要把輸入的所有像素點連接起來,需要指定輸入層神經元個數和輸出層神經元個數，所以需要規定輸入的feature的大小。而SPP-NET正好解決了這個問題。

如果原圖輸入是224x224，對於conv5出來後的輸出，是13x13x256的，可以理解成有256個這樣的filter，每個filter對應一張13x13的activation map.如果像上圖那樣將activation map pooling成4x4 2x2 1x1三張子圖，做max pooling後，出來的特徵就是固定長度的(16+4+1)x256那麼多的維度了.如果原圖的輸入不是224x224，出來的特徵依然是(16+4+1)x256；直覺地說，可以理解成將原來固定大小為(3x3)窗口的pool5改成了自適應窗口大小，窗口的大小和activation map成比例，保證了經過pooling後出來的feature的長度是一致的.

總結而言，當網路輸入的是一張任意大小的圖片，這個時候我們可以一直進行卷積、池化，直到網路的倒數幾層的時候，也就是我們即將與全連接層連接的時候，就要使用金字塔池化，使得任意大小的特徵圖都能夠轉換成固定大小的特徵向量，這就是空間金字塔池化的意義（多尺度特徵提取出固定大小的特徵向量）。

ROI pooling layer實際上是SPP-NET的一個精簡版，SPP-NET對每個proposal使用了不同大小的金字塔映射，而ROI pooling layer只需要下采樣到一個7x7的特徵圖.對於VGG16網路conv5_3有512個特徵圖，這樣所有region proposal對應了一個7*7*512維度的特徵向量作為全連接層的輸入.

為什麼要pooling成7×7的尺度？是為了能夠共享權重。Faster RCNN除了用到VGG前幾層的卷積之外，最後的全連接層也可以繼續利用。當所有的RoIs都被pooling成（512\×7\×7）的feature map後，將它reshape 成一個一維的向量，就可以利用VGG16預訓練的權重，初始化前兩層全連接.

那麼經過何種變換才能從圖11中的窗口P變為窗口呢？比較簡單的思路就是：

注意：只有當Proposal和Ground Truth比較接近時（線性問題），我們才能將其作為訓練樣本訓練我們的線性回歸模型，否則會導致訓練的回歸模型不work（當Proposal跟GT離得較遠，就是復雜的非線性問題了，此時用線性回歸建模顯然不合理）.這個也是G-CNN: an Iterative Grid Based Object Detector多次迭代實現目標准確定位的關鍵. 線性回歸就是給定輸入的特徵向量X，學習一組參數W，使得經過線性回歸後的值跟真實值Y(Ground Truth)非常接近.即.那麼Bounding-box中我們的輸入以及輸出分別是什麼呢？

如上圖中標識：
① rpn_cls：60*40*512-d ⊕ 1*1*512*18 > 60*40*92 逐像素對其9個Anchor box進行二分類
② rpn_bbox：60*40*512-d ⊕ 1*1*512*36>60*40*9*4 逐像素得到其9個Anchor box四個坐標信息

逐像素對Anchors分類標記
① 去除掉超過1000*600這原圖的邊界的anchor box
② 如果anchor box與ground truth的IoU值最大，標記為正樣本，label=1
③ 如果anchor box與ground truth的IoU>0.7，標記為正樣本，label=1
④ 如果anchor box與ground truth的IoU<0.3，標記為負樣本，label=0
剩下的既不是正樣本也不是負樣本，不用於最終訓練，label=-1

逐像素Bbox回歸糾正
除了對anchor box進行標記外，另一件事情就是計算anchor box與ground truth之間的偏移量
令：ground truth:標定的框也對應一個中心點位置坐標x ,y 和寬高w ,h
anchor box: 中心點位置坐標x_a,y_a和寬高w_a,h_a
所以，偏移量：
△x=(x -x_a)/w_a △y=(y -y_a)/h_a
△w=log(w /w_a) △h=log(h /h_a)
通過ground truth box與預測的anchor box之間的差異來進行學習，從而是RPN網路中的權重能夠學習到預測box的能力

接著進一步對Anchors進行越界剔除和使用nms非最大值抑制，剔除掉重疊的框；比如，設定IoU為0.7的閾值，即僅保留覆蓋率不超過0.7的局部最大分數的box（粗篩）。最後留下大約2000個anchor，然後再取前N個box（比如300個）；這樣，進入到下一層ROI Pooling時region proposal大約只有300個。

參考文獻：

⑶ 圖像演算法方向的劃分

劃分有：
圖像加密，數字水印，圖像去噪，圖像分割，圖像配准，圖像恢復，圖像溶合，圖像拼貼，特徵提取。

⑷ 農夫過河的圖演算法

#include<iostream>

using namespace std;

#define VertexNum 16 //最大頂點數

typedef struct // 圖的頂點
{
int farmer; // 農夫
int wolf; // 狼
int sheep; // 羊
int veget; // 白菜
}Vertex;

typedef struct
{
int vertexNum; // 圖的當前頂點數
Vertex vertex[VertexNum]; // 頂點向量（代表頂點）
bool Edge[VertexNum][VertexNum]; // 鄰接矩陣. 用於存儲圖中的邊，其矩陣元素個數取決於頂點個數，與邊數無關
}AdjGraph; // 定義圖的鄰接矩陣存儲結構

bool visited[VertexNum] = {false}; // 對已訪問的頂點進行標記（圖的遍歷）
int retPath[VertexNum] = {-1}; // 保存DFS搜索到的路徑，即與某頂點到下一頂點的路徑

// 查找頂點（F，W，S，V）在頂點向量中的位置
int locate(AdjGraph *graph, int farmer, int wolf, int sheep, int veget)
{
// 從0開始查找
for (int i = 0; i < graph->vertexNum; i++)
{
if ( graph->vertex[i].farmer == farmer && graph->vertex[i].wolf == wolf
&& graph->vertex[i].sheep == sheep && graph->vertex[i].veget == veget )
{
return i; //返回當前位置
}
}

return -1; //沒有找到此頂點
}

// 判斷目前的（F，W，S，V）是否安全
bool isSafe(int farmer, int wolf, int sheep, int veget)
{
//當農夫與羊不在一起時，狼與羊或羊與白菜在一起是不安全的
if ( farmer != sheep && (wolf == sheep || sheep == veget) )
{
return false;
}
else
{
return true; // 安全返回true
}
}

// 判斷狀態i與狀態j之間是否可轉換
bool isConnect(AdjGraph *graph, int i, int j)
{
int k = 0;

if (graph->vertex[i].wolf != graph->vertex[j].wolf)
{
k++;
}

if (graph->vertex[i].sheep != graph->vertex[j].sheep)
{
k++;
}

if (graph->vertex[i].veget != graph->vertex[j].veget)
{
k++;
}

// 以上三個條件不同時滿足兩個且農夫狀態改變時，返回真, 也即農夫每次只能帶一件東西過橋
if (graph->vertex[i].farmer != graph->vertex[j].farmer && k <= 1)
{
return true;
}
else
{
return false;
}
}

// 創建連接圖
void CreateG(AdjGraph *graph)
{
int i = 0;
int j = 0;

// 生成所有安全的圖的頂點
for (int farmer = 0; farmer <= 1; farmer++)
{
for (int wolf = 0; wolf <= 1; wolf++)
{
for (int sheep = 0; sheep <= 1; sheep++)
{
for (int veget = 0; veget <= 1; veget++)
{
if (isSafe(farmer, wolf, sheep, veget))
{
graph->vertex[i].farmer = farmer;
graph->vertex[i].wolf = wolf;
graph->vertex[i].sheep = sheep;
graph->vertex[i].veget = veget;
i++;
}
}
}
}
}

// 鄰接矩陣初始化即建立鄰接矩陣
graph->vertexNum = i;
for (i = 0; i < graph->vertexNum; i++)
{
for (j = 0; j < graph->vertexNum; j++)
{
// 狀態i與狀態j之間可轉化，初始化為1，否則為0
if (isConnect(graph, i, j))
{
graph->Edge[i][j] = graph->Edge[j][i] = true;
}
else
{
graph->Edge[i][j] = graph->Edge[j][i] = false;
}
}
}

return;
}

// 判斷在河的那一邊
char* judgement(int state)
{
return ( (0 == state) ? "左岸" : "右岸" );
}

// 輸出從u到v的簡單路徑，即頂點序列中不重復出現的路徑
void printPath(AdjGraph *graph, int start, int end)
{
int i = start;

cout << "farmer" << ", wolf" << ", sheep" << ", veget" << endl;

while (i != end)
{
cout << "(" << judgement(graph->vertex[i].farmer) << ", " << judgement(graph->vertex[i].wolf)
<< ", " << judgement(graph->vertex[i].sheep) << ", " << judgement(graph->vertex[i].veget) << ")";
cout << endl;

i = retPath[i];
}

cout << "(" << judgement(graph->vertex[i].farmer) << ", " << judgement(graph->vertex[i].wolf)
<< ", " << judgement(graph->vertex[i].sheep) << ", " << judgement(graph->vertex[i].veget) << ")";
cout << endl;
}

// 深度優先搜索從u到v的簡單路徑 //DFS--Depth First Search
void dfsPath(AdjGraph *graph, int start, int end)
{
int i = 0;
visited[start] = true; //標記已訪問過的頂點

if (start == end)
{
return ;
}

for (i = 0; i < graph->vertexNum; i++)
{
if (graph->Edge[start][i] && !visited[i])
{
retPath[start] = i;
dfsPath(graph, i, end);
}
}
}

int main()
{
AdjGraph graph;
CreateG(&graph);

int start = locate(&graph, 0, 0, 0, 0);
int end = locate(&graph, 1, 1, 1, 1);
dfsPath(&graph, start, end);

if (visited[end]) // 有結果
{
printPath(&graph, start, end);
return 0;
}

return -1;
}

⑸ 關於C++圖演算法中的VISITED和UNVISITED的問題

一般是自定義的全局變數型標志數組（邏輯型或者數值型），每個元素代表圖中的一個頂點，你當然也可以用局部變數來實現，只是演算法參數可能需要增加一個了（比如深度優先）
除非那個圖演算法來源教科書或者資料中前面已經定義了

⑹ 數據結構中圖演算法都能解答生活中什麼樣的問題

直觀點就是線路規劃,流量分析之類的直觀圖結構問題.
廣義來說很多包含關系對的邏輯結構都可以轉化成圖,比如匹配問題可以轉化成二分圖.

⑺ 圖演算法中權是什麼

圖演算法中權的是一個有意義的量，可以是時間，長度，花費（代價）等

⑻ 求常用的圖演算法（C語言描述）

/*Bezier曲線的Casteljau演算法*/

float decas(degree,codff,t)
float coeff[];
float t;
int degree;
{
int r,i;
float t1;
float codffa[10];
t1=1.0-t;
for(i=0;i<=degree;i++)
coeffa[i]=coeff[i];
for(r=1;r<degree;r++)
for(i=0;i<=degree-r;i++)
{
coeffa[i]=t1*coeffa[i]+t*coeffa[i+1];
}
return (coeffa[0]);
}

/*B樣條曲線—deBoor分割演算法*/

float deboor(degree,coeff,knot,u,i)
float coeff[],knot[];
float u;
int degree,i;
{
int k,j;
float t1,t2;
float coeffa[30];
for(j=i-degree+1;j<=i+1;j++)
coeffa[j]=coeff[j-i+degree-1];
for(k=1;i<=degree;k++)
forj=i+1;j>=i-degree+k+1;j--)
{
t1=(knot[j+degree-k]-u)/(knot[j+degree-k]-knot[j-1]);
t2=1.0-t1;
coeffa[j]=t1*coeffa[j-1]+t2*coeffa[j];
}
return (coeffa[i+1]);
}

/*Bezier曲線的Horner演算法*/

float hornbez(degree,coeff,t)
int degree;
float coff[];
float t;
{
int i,n;
float fact,t1,aux;
t1=1.0-t;fact=1.0;n=1;
aux=coeff[0]*t1;

for(i=1;i<degree;i++)
{
face=fact*t;
n=n*(degree-i+1)/i;
aux=(aux+fact*n*coeff[i])*t1;
}
aux=aux+fact*t*codff[degree];
return aux;
}

⑼ 演算法：C語言實現（圖演算法）裡面深度和廣度優先搜索的參數里都是在傳入一條起始邊而不是一個點，為什麼

一般情況下，dfs和bfs都是傳入點，然後從點擴展出去。
兩個結構大概是這樣的
void dfs(int u)
{
if (所有節點都遍歷)
return;
找出所有與u相連的點v且還未被訪問的節點
{
v置訪問標記；
dfs(v);
}
}

void bfs()
{
根節點入隊；
while (隊列為空）
{
u = 隊頭節點出隊；
找出所有與u相連的點v且還未被訪問的節點
{
v置訪問標記；
v入隊；
}
}
}

⑽ 如何完全圖生成最小二叉樹

這種樹成為帶度限制條件的生成樹。簡稱度限制生成樹。求解方法我看了，但沒看懂。給你直接粘過來太亂。神牛自己慢慢研究去吧。在google里網路一下就行^_^
這里是我幫你搜好的幾個網址
http://hi..com/liveroom/blog/item/978e7d2305d2d4479358070f.html