基於人工蜂群演算法的兵力投送

『叄』 java人工蜂群演算法求解TSP問題

一、人工蜂群演算法的介紹

人工蜂群演算法(Artificial Bee Colony, ABC)是由Karaboga於2005年提出的一種新穎的基於群智能的全局優化演算法，其直觀背景來源於蜂群的采蜜行為，蜜蜂根據各自的分工進行不同的活動，並實現蜂群信息的共享和交流，從而找到問題的最優解。人工蜂群演算法屬於群智能演算法的一種。

二、人工蜂群演算法的原理

1、原理

標準的ABC演算法通過模擬實際蜜蜂的采蜜機制將人工蜂群分為3類: 采蜜蜂、觀察蜂和偵察蜂。整個蜂群的目標是尋找花蜜量最大的蜜源。在標準的ABC演算法中，采蜜蜂利用先前的蜜源信息尋找新的蜜源並與觀察蜂分享蜜源信息；觀察蜂在蜂房中等待並依據采蜜蜂分享的信息尋找新的蜜源；偵查蜂的任務是尋找一個新的有價值的蜜源，它們在蜂房附近隨機地尋找蜜源。

假設問題的解空間是。

代碼：

[cpp]view plain

『肆』 人工蜂群演算法適合在srm中應用嗎

蜜蜂是一種群居昆蟲，雖然單個昆蟲的行為極其簡單，但是由單個簡單的個體所組成的群體卻表現出極其復雜的行為。真實的蜜蜂種群能夠在任何環境下，以極高的效率從食物源（花朵）中採集花蜜；同時，它們能適應環境的改變。
蜂群產生群體智慧的最小搜索模型包含基本的三個組成要素：食物源、被僱傭的蜜蜂（employed foragers）和未被僱傭的蜜蜂（unemployed foragers）；兩種最為基本的行為模型：為食物源招募（recruit）蜜蜂和放棄（abandon）某個食物源。
(1)食物源：食物源的價值由多方面的因素決定，如：它離蜂巢的遠近，包含花蜜的豐富程度和獲得花蜜的難易程度。使用單一的參數，食物源的「收益率」（profitability），來代表以上各個因素。
(2)被僱用的蜜蜂：也稱引領蜂（Leader），其與所採集的食物源一一對應。引領蜂儲存有某一個食物源的相關信息（相對於蜂巢的距離、方向、食物源的豐富程度等）並且將這些信息以一定的概率與其他蜜蜂分享。
(3)未被僱用的蜜蜂：其主要任務是尋找和開採食物源。有兩種未被僱用的蜜蜂：偵查蜂（Scouter）和跟隨蜂（Follower）。偵察蜂搜索蜂巢附近的新食物源；跟隨蜂等在蜂巢裡面並通過與引領蜂分享相關信息找到食物源。一般情況下，偵察蜂的平均數目是蜂群的5%-20%。

『伍』 人工蜂群演算法matlab蜂群種群大小怎麼設定

%/* ABC algorithm coded using MATLAB language */

%/* Artificial Bee Colony (ABC) is one of the most recently defined algorithms by Dervis Karaboga in 2005, motivated by the intelligent behavior of honey bees. */

%/* Referance Papers*/

%/*D. Karaboga, AN IDEA BASED ON HONEY BEE SWARM FOR NUMERICAL OPTIMIZATION,TECHNICAL REPORT-TR06, Erciyes University, Engineering Faculty, Computer Engineering Department 2005.*/

%/*D. Karaboga, B. Basturk, A powerful and Efficient Algorithm for Numerical Function Optimization: Artificial Bee Colony (ABC) Algorithm, Journal of Global Optimization, Volume:39, Issue:3,pp:459-171, November 2007,ISSN:0925-5001 , doi: 10.1007/s10898-007-9149-x */

%/*D. Karaboga, B. Basturk, On The Performance Of Artificial Bee Colony (ABC) Algorithm, Applied Soft Computing,Volume 8, Issue 1, January 2008, Pages 687-697. */

%/*D. Karaboga, B. Akay, A Comparative Study of Artificial Bee Colony Algorithm, Applied Mathematics and Computation, 214, 108-132, 2009. */

%/*Copyright ?2009 Erciyes University, Intelligent Systems Research Group, The Dept. of Computer Engineering*/

%/*Contact:
%Dervis Karaboga ([email protected] )
%Bahriye Basturk Akay ([email protected])
%*/

clear all
close all
clc

%/* Control Parameters of ABC algorithm*/
NP=20; %/* The number of colony size (employed bees+onlooker bees)*/
FoodNumber=NP/2; %/*The number of food sources equals the half of the colony size*/
limit=100; %/*A food source which could not be improved through "limit" trials is abandoned by its employed bee*/
maxCycle=2500; %/*The number of cycles for foraging {a stopping criteria}*/

%/* Problem specific variables*/
objfun='Sphere'; %cost function to be optimized
D=100; %/*The number of parameters of the problem to be optimized*/
ub=ones(1,D)*100; %/*lower bounds of the parameters. */
lb=ones(1,D)*(-100);%/*upper bound of the parameters.*/

runtime=1;%/*Algorithm can be run many times in order to see its robustness*/

%Foods [FoodNumber][D]; /*Foods is the population of food sources. Each row of Foods matrix is a vector holding D parameters to be optimized. The number of rows of Foods matrix equals to the FoodNumber*/
%ObjVal[FoodNumber]; /*f is a vector holding objective function values associated with food sources */
%Fitness[FoodNumber]; /*fitness is a vector holding fitness (quality) values associated with food sources*/
%trial[FoodNumber]; /*trial is a vector holding trial numbers through which solutions can not be improved*/
%prob[FoodNumber]; /*prob is a vector holding probabilities of food sources (solutions) to be chosen*/
%solution [D]; /*New solution (neighbour) proced by v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) j is a randomly chosen parameter and k is a randomlu chosen solution different from i*/
%ObjValSol; /*Objective function value of new solution*/
%FitnessSol; /*Fitness value of new solution*/
%neighbour, param2change; /*param2change corrresponds to j, neighbour corresponds to k in equation v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij})*/
%GlobalMin; /*Optimum solution obtained by ABC algorithm*/
%GlobalParams[D]; /*Parameters of the optimum solution*/
%GlobalMins[runtime]; /*GlobalMins holds the GlobalMin of each run in multiple runs*/

GlobalMins=zeros(1,runtime);

for r=1:runtime

% /*All food sources are initialized */
%/*Variables are initialized in the range [lb,ub]. If each parameter has different range, use arrays lb[j], ub[j] instead of lb and ub */

Range = repmat((ub-lb),[FoodNumber 1]);
Lower = repmat(lb, [FoodNumber 1]);
Foods = rand(FoodNumber,D) .* Range + Lower;

ObjVal=feval(objfun,Foods);
Fitness=calculateFitness(ObjVal);

%reset trial counters
trial=zeros(1,FoodNumber);

%/*The best food source is memorized*/
BestInd=find(ObjVal==min(ObjVal));
BestInd=BestInd(end);
GlobalMin=ObjVal(BestInd);
GlobalParams=Foods(BestInd,:);

iter=1;
while ((iter <= maxCycle)),

%%%%%%%%% EMPLOYED BEE PHASE %%%%%%%%%%%%%%%%%%%%%%%%
for i=1:(FoodNumber)

%/*The parameter to be changed is determined randomly*/
Param2Change=fix(rand*D)+1;

%/*A randomly chosen solution is used in procing a mutant solution of the solution i*/
neighbour=fix(rand*(FoodNumber))+1;

%/*Randomly selected solution must be different from the solution i*/
while(neighbour==i)
neighbour=fix(rand*(FoodNumber))+1;
end;

sol=Foods(i,:);
% /*v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) */
sol(Param2Change)=Foods(i,Param2Change)+(Foods(i,Param2Change)-Foods(neighbour,Param2Change))*(rand-0.5)*2;

% /*if generated parameter value is out of boundaries, it is shifted onto the boundaries*/
ind=find(sol<lb);
sol(ind)=lb(ind);
ind=find(sol>ub);
sol(ind)=ub(ind);

%evaluate new solution
ObjValSol=feval(objfun,sol);
FitnessSol=calculateFitness(ObjValSol);

% /*a greedy selection is applied between the current solution i and its mutant*/
if (FitnessSol>Fitness(i)) %/*If the mutant solution is better than the current solution i, replace the solution with the mutant and reset the trial counter of solution i*/
Foods(i,:)=sol;
Fitness(i)=FitnessSol;
ObjVal(i)=ObjValSol;
trial(i)=0;
else
trial(i)=trial(i)+1; %/*if the solution i can not be improved, increase its trial counter*/
end;

end;

%%%%%%%%%%%%%%%%%%%%%%%% CalculateProbabilities %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%/* A food source is chosen with the probability which is proportioal to its quality*/
%/*Different schemes can be used to calculate the probability values*/
%/*For example prob(i)=fitness(i)/sum(fitness)*/
%/*or in a way used in the metot below prob(i)=a*fitness(i)/max(fitness)+b*/
%/*probability values are calculated by using fitness values and normalized by dividing maximum fitness value*/

prob=(0.9.*Fitness./max(Fitness))+0.1;

%%%%%%%%%%%%%%%%%%%%%%%% ONLOOKER BEE PHASE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

i=1;
t=0;
while(t<FoodNumber)
if(rand<prob(i))
t=t+1;
%/*The parameter to be changed is determined randomly*/
Param2Change=fix(rand*D)+1;

%/*A randomly chosen solution is used in procing a mutant solution of the solution i*/
neighbour=fix(rand*(FoodNumber))+1;

%/*Randomly selected solution must be different from the solution i*/
while(neighbour==i)
neighbour=fix(rand*(FoodNumber))+1;
end;

sol=Foods(i,:);
% /*v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) */
sol(Param2Change)=Foods(i,Param2Change)+(Foods(i,Param2Change)-Foods(neighbour,Param2Change))*(rand-0.5)*2;

% /*if generated parameter value is out of boundaries, it is shifted onto the boundaries*/
ind=find(sol<lb);
sol(ind)=lb(ind);
ind=find(sol>ub);
sol(ind)=ub(ind);

%evaluate new solution
ObjValSol=feval(objfun,sol);
FitnessSol=calculateFitness(ObjValSol);

% /*a greedy selection is applied between the current solution i and its mutant*/
if (FitnessSol>Fitness(i)) %/*If the mutant solution is better than the current solution i, replace the solution with the mutant and reset the trial counter of solution i*/
Foods(i,:)=sol;
Fitness(i)=FitnessSol;
ObjVal(i)=ObjValSol;
trial(i)=0;
else
trial(i)=trial(i)+1; %/*if the solution i can not be improved, increase its trial counter*/
end;
end;

i=i+1;
if (i==(FoodNumber)+1)
i=1;
end;
end;

%/*The best food source is memorized*/
ind=find(ObjVal==min(ObjVal));
ind=ind(end);
if (ObjVal(ind)<GlobalMin)
GlobalMin=ObjVal(ind);
GlobalParams=Foods(ind,:);
end;

%%%%%%%%%%%% SCOUT BEE PHASE %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%/*determine the food sources whose trial counter exceeds the "limit" value.
%In Basic ABC, only one scout is allowed to occur in each cycle*/

ind=find(trial==max(trial));
ind=ind(end);
if (trial(ind)>limit)
Bas(ind)=0;
sol=(ub-lb).*rand(1,D)+lb;
ObjValSol=feval(objfun,sol);
FitnessSol=calculateFitness(ObjValSol);
Foods(ind,:)=sol;
Fitness(ind)=FitnessSol;
ObjVal(ind)=ObjValSol;
end;

fprintf('Ýter=%d ObjVal=%g\n',iter,GlobalMin);
iter=iter+1;

end % End of ABC

GlobalMins(r)=GlobalMin;
end; %end of runs

save all

『陸』 人工蜂群演算法里太多比喻了，能不能就演算法本身的步驟來講講

直接給你JAVA代碼吧，看的簡單易懂
import java.lang.Math;

public class beeColony {

/* Control Parameters of ABC algorithm*/
int NP=20; /* The number of colony size (employed bees+onlooker bees)*/
int FoodNumber = NP/2; /*The number of food sources equals the half of the colony size*/
int limit = 100; /*A food source which could not be improved through "limit" trials is abandoned by its employed bee*/
int maxCycle = 2500; /*The number of cycles for foraging {a stopping criteria}*/

/* Problem specific variables*/
int D = 100; /*The number of parameters of the problem to be optimized*/
double lb = -5.12; /*lower bound of the parameters. */
double ub = 5.12; /*upper bound of the parameters. lb and ub can be defined as arrays for the problems of which parameters have different bounds*/

int runtime = 30; /*Algorithm can be run many times in order to see its robustness*/

int dizi1[]=new int[10];
double Foods[][]=new double[FoodNumber][D]; /*Foods is the population of food sources. Each row of Foods matrix is a vector holding D parameters to be optimized. The number of rows of Foods matrix equals to the FoodNumber*/
double f[]=new double[FoodNumber]; /*f is a vector holding objective function values associated with food sources */
double fitness[]=new double[FoodNumber]; /*fitness is a vector holding fitness (quality) values associated with food sources*/
double trial[]=new double[FoodNumber]; /*trial is a vector holding trial numbers through which solutions can not be improved*/
double prob[]=new double[FoodNumber]; /*prob is a vector holding probabilities of food sources (solutions) to be chosen*/
double solution[]=new double[D]; /*New solution (neighbour) proced by v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) j is a randomly chosen parameter and k is a randomlu chosen solution different from i*/

double ObjValSol; /*Objective function value of new solution*/
double FitnessSol; /*Fitness value of new solution*/
int neighbour, param2change; /*param2change corrresponds to j, neighbour corresponds to k in equation v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij})*/

double GlobalMin; /*Optimum solution obtained by ABC algorithm*/
double GlobalParams[]=new double[D]; /*Parameters of the optimum solution*/
double GlobalMins[]=new double[runtime];
/*GlobalMins holds the GlobalMin of each run in multiple runs*/
double r; /*a random number in the range [0,1)*/

/*a function pointer returning double and taking a D-dimensional array as argument */
/*If your function takes additional arguments then change function pointer definition and lines calling "...=function(solution);" in the code*/

// typedef double (*FunctionCallback)(double sol[D]);

/*benchmark functions */

// double sphere(double sol[D]);
// double Rosenbrock(double sol[D]);
// double Griewank(double sol[D]);
// double Rastrigin(double sol[D]);

/*Write your own objective function name instead of sphere*/
// FunctionCallback function = &sphere;

/*Fitness function*/
double CalculateFitness(double fun)
{
double result=0;
if(fun>=0)
{
result=1/(fun+1);
}
else
{

result=1+Math.abs(fun);
}
return result;
}

/*The best food source is memorized*/
void MemorizeBestSource()
{
int i,j;

for(i=0;i<FoodNumber;i++)
{
if (f[i]<GlobalMin)
{
GlobalMin=f[i];
for(j=0;j<D;j++)
GlobalParams[j]=Foods[i][j];
}
}
}

/*Variables are initialized in the range [lb,ub]. If each parameter has different range, use arrays lb[j], ub[j] instead of lb and ub */
/* Counters of food sources are also initialized in this function*/

void init(int index)
{
int j;
for (j=0;j<D;j++)
{
r = ( (double)Math.random()*32767 / ((double)32767+(double)(1)) );
Foods[index][j]=r*(ub-lb)+lb;
solution[j]=Foods[index][j];
}
f[index]=calculateFunction(solution);
fitness[index]=CalculateFitness(f[index]);
trial[index]=0;
}

/*All food sources are initialized */
void initial()
{
int i;
for(i=0;i<FoodNumber;i++)
{
init(i);
}
GlobalMin=f[0];
for(i=0;i<D;i++)
GlobalParams[i]=Foods[0][i];

}

void SendEmployedBees()
{
int i,j;
/*Employed Bee Phase*/
for (i=0;i<FoodNumber;i++)
{
/*The parameter to be changed is determined randomly*/
r = ((double) Math.random()*32767 / ((double)(32767)+(double)(1)) );
param2change=(int)(r*D);

/*A randomly chosen solution is used in procing a mutant solution of the solution i*/
r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
neighbour=(int)(r*FoodNumber);

/*Randomly selected solution must be different from the solution i*/
// while(neighbour==i)
// {
// r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
// neighbour=(int)(r*FoodNumber);
// }
for(j=0;j<D;j++)
solution[j]=Foods[i][j];

/*v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) */
r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
solution[param2change]=Foods[i][param2change]+(Foods[i][param2change]-Foods[neighbour][param2change])*(r-0.5)*2;

/*if generated parameter value is out of boundaries, it is shifted onto the boundaries*/
if (solution[param2change]<lb)
solution[param2change]=lb;
if (solution[param2change]>ub)
solution[param2change]=ub;
ObjValSol=calculateFunction(solution);
FitnessSol=CalculateFitness(ObjValSol);

/*a greedy selection is applied between the current solution i and its mutant*/
if (FitnessSol>fitness[i])
{

/*If the mutant solution is better than the current solution i, replace the solution with the mutant and reset the trial counter of solution i*/
trial[i]=0;
for(j=0;j<D;j++)
Foods[i][j]=solution[j];
f[i]=ObjValSol;
fitness[i]=FitnessSol;
}
else
{ /*if the solution i can not be improved, increase its trial counter*/
trial[i]=trial[i]+1;
}

}

/*end of employed bee phase*/

}

/* A food source is chosen with the probability which is proportioal to its quality*/
/*Different schemes can be used to calculate the probability values*/
/*For example prob(i)=fitness(i)/sum(fitness)*/
/*or in a way used in the metot below prob(i)=a*fitness(i)/max(fitness)+b*/
/*probability values are calculated by using fitness values and normalized by dividing maximum fitness value*/
void CalculateProbabilities()
{
int i;
double maxfit;
maxfit=fitness[0];
for (i=1;i<FoodNumber;i++)
{
if (fitness[i]>maxfit)
maxfit=fitness[i];
}

for (i=0;i<FoodNumber;i++)
{
prob[i]=(0.9*(fitness[i]/maxfit))+0.1;
}

}

void SendOnlookerBees()
{

int i,j,t;
i=0;
t=0;
/*onlooker Bee Phase*/
while(t<FoodNumber)
{

r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
if(r<prob[i]) /*choose a food source depending on its probability to be chosen*/
{
t++;

/*The parameter to be changed is determined randomly*/
r = ((double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
param2change=(int)(r*D);

/*A randomly chosen solution is used in procing a mutant solution of the solution i*/
r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
neighbour=(int)(r*FoodNumber);

/*Randomly selected solution must be different from the solution i*/
while(neighbour == i)
{
//System.out.println(Math.random()*32767+" "+32767);
r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
neighbour=(int)(r*FoodNumber);
}
for(j=0;j<D;j++)
solution[j]=Foods[i][j];

/*v_{ij}=x_{ij}+\phi_{ij}*(x_{kj}-x_{ij}) */
r = ( (double)Math.random()*32767 / ((double)(32767)+(double)(1)) );
solution[param2change]=Foods[i][param2change]+(Foods[i][param2change]-Foods[neighbour][param2change])*(r-0.5)*2;

/*if generated parameter value is out of boundaries, it is shifted onto the boundaries*/
if (solution[param2change]<lb)
solution[param2change]=lb;
if (solution[param2change]>ub)
solution[param2change]=ub;
ObjValSol=calculateFunction(solution);
FitnessSol=CalculateFitness(ObjValSol);

/*a greedy selection is applied between the current solution i and its mutant*/
if (FitnessSol>fitness[i])
{
/*If the mutant solution is better than the current solution i, replace the solution with the mutant and reset the trial counter of solution i*/
trial[i]=0;
for(j=0;j<D;j++)
Foods[i][j]=solution[j];
f[i]=ObjValSol;
fitness[i]=FitnessSol;
}
else
{ /*if the solution i can not be improved, increase its trial counter*/
trial[i]=trial[i]+1;
}
} /*if */
i++;
if (i==FoodNumber-1)
i=0;
}/*while*/

/*end of onlooker bee phase */
}

/*determine the food sources whose trial counter exceeds the "limit" value. In Basic ABC, only one scout is allowed to occur in each cycle*/
void SendScoutBees()
{
int maxtrialindex,i;
maxtrialindex=0;
for (i=1;i<FoodNumber;i++)
{
if (trial[i]>trial[maxtrialindex])
maxtrialindex=i;
}
if(trial[maxtrialindex]>=limit)
{
init(maxtrialindex);
}
}

double calculateFunction(double sol[])
{
return Rastrigin (sol);
}
double sphere(double sol[])
{
int j;
double top=0;
for(j=0;j<D;j++)
{
top=top+sol[j]*sol[j];
}
return top;
}

double Rosenbrock(double sol[])
{
int j;
double top=0;
for(j=0;j<D-1;j++)
{
top=top+100*Math.pow((sol[j+1]-Math.pow((sol[j]),(double)2)),(double)2)+Math.pow((sol[j]-1),(double)2);
}
return top;
}

double Griewank(double sol[])
{
int j;
double top1,top2,top;
top=0;
top1=0;
top2=1;
for(j=0;j<D;j++)
{
top1=top1+Math.pow((sol[j]),(double)2);
top2=top2*Math.cos((((sol[j])/Math.sqrt((double)(j+1)))*Math.PI)/180);

}
top=(1/(double)4000)*top1-top2+1;
return top;
}

double Rastrigin(double sol[])
{
int j;
double top=0;

for(j=0;j<D;j++)
{
top=top+(Math.pow(sol[j],(double)2)-10*Math.cos(2*Math.PI*sol[j])+10);
}
return top;
}
}

使用方法是：
public class test {
static beeColony bee=new beeColony();

public static void main(String[] args) {
int iter=0;
int run=0;
int j=0;
double mean=0;
//srand(time(NULL));
for(run=0;run<bee.runtime;run++)
{
bee.initial();
bee.MemorizeBestSource();
for (iter=0;iter<bee.maxCycle;iter++)
{
bee.SendEmployedBees();
bee.CalculateProbabilities();
bee.SendOnlookerBees();
bee.MemorizeBestSource();
bee.SendScoutBees();
}
for(j=0;j<bee.D;j++)
{
//System.out.println("GlobalParam[%d]: %f\n",j+1,GlobalParams[j]);
System.out.println("GlobalParam["+(j+1)+"]:"+bee.GlobalParams[j]);
}
//System.out.println("%d. run: %e \n",run+1,GlobalMin);
System.out.println((run+1)+".run:"+bee.GlobalMin);
bee.GlobalMins[run]=bee.GlobalMin;
mean=mean+bee.GlobalMin;
}
mean=mean/bee.runtime;
//System.out.println("Means of %d runs: %e\n",runtime,mean);
System.out.println("Means of "+bee.runtime+"runs: "+mean);

}

}

『柒』 蜂群演算法與人工蜂群演算法有什麼的區別嗎

都是一樣的，為什麼有的會帶上「人工」呢？只是因為這些只能演算法都是「人」仿照動物行為而創造的，所以有時候才會帶上「人工」兩個字。但是指的是一個東西。
例如神經網路，也有人喜歡說是人工神經網路

『捌』 智慧工地中的圖像感測技術的應用進展

本文內容來自以下文章：

楊曉嬌,於忠,冮軍.智慧工地中的圖像感測技術的應用進展[J].四川建築,2021,41(S1):41-44.

摘要：文章對智慧工地中的圖像感測技術的發展歷程、以及圖像技術、視頻技術、激光雷達點雲技術在建築工地中的應用作介紹，並介紹了智能演算法在圖像處理技術領域的發展應用。最後提出為了更好地滿足施工監管的需求，圖像技術可以通過視頻技術、激光雷達點雲技術在時間、空間上進行交叉驗證，以提高圖像識別的准確性。在智能演算法與圖像耦合技術方面應結合三維技術形成更加准確地實時反饋信號指導工程施工。

關鍵詞：圖像感測技術; 視頻技術; 激光雷達點雲技術; 智能演算法

智慧工地和智慧建築的興起與當今智能化、信息化的發展有著緊密的聯系。隨著我國城鎮化進程的加快，建築施工過程日益復雜，施工現場安全問題，如勞務人員安全帽和安全繩佩戴、施工現場臨時用電混亂、臨邊防護等問題，也日益凸顯出來，使得傳統施工安全監管技術已經無法滿足目前現場施工安全的要求。藉助計算機和人工智慧技術的快速發展，圖像感測技術憑借 處理精度高、靈活性強、再現性好、適用面廣等特點 成功應用於建築施工安全管理等過程，為項目管理人員提供施工現場的安全隱患、施工動態及進度的實時反饋，提高了建築施工安全管理效率。

進入21世紀，圖像感測技術的應用范圍被逐漸拓寬，甚至在某些領域已經取得突破。然而，對計算機計算速度、存儲容量要求較高，圖像處理使用頻帶較寬、以及在成像、傳輸方面還有一定的技術難度等因素，制約了圖像感測技術的進一步發展。

目前，智慧工地系統中包含了大量的各類感測器和核心的數據實時處理技術，也由此帶來了大量的數據獲取、傳遞和處理。隨著智能技術的發展，視頻圖像信息在建築信息數據中的佔比越來越大，利用圖像感測技術對建築施工進度、人員安全帶和防護柵欄等安全裝置狀態識別、工程質量評價以及施工現場揚塵監測等過程進行實時反饋，實現建築施工過程中的信息識別、安全監管、決策分析等功能，使得圖像感測技術成為建築施工管理過程中的重要技術手段之一。

1 圖像及視頻感測技術在智慧工地中的應用

1.1 圖像技術在建築工地中的應用

圖像技術總體上可以分為 圖像分析、圖像重建和圖像的像質改善 三大部分，在建築施工中圖像技術一般用於圖像分析，如人臉識別、安全帽/繩識別、火災識別、混凝土結構監控等。

1. 2 視頻技術在建築工地的應用

建築工地是一個復雜龐大的區域，利用視頻技術對建築物內部各個位置情況進行監管，對建築施工現場安全管理進行實時監控。從現有的研究和應用案例來看，建築工地對視頻監控的需求主要集中在: 地基基礎、地面施工、高層作業以及文明施工檢查 等階段。其中， 安全問題 是各個階段最突出的問題之一，利用視頻技術對施工現場的深基坑、高邊坡支護安全、模板工程安全、臨邊洞口防護、腳手架搭設安全等過程進行監管，既減輕了監管人員的工作強度，又加強了建設行政主管部門以及監管機構的調控監控力度，提高了工作效率。

1.3 激光雷達點雲技術在建築工地的應用

近年來，利用激光雷達技術處理大規模的地理空間數據，發展了計算機視覺、計算機圖形學。從有關於建築重建、圖像以及激光雷達建模的文獻中發現，其中很大一部分內容致力於基於圖像的方法進行 建築重建 。激光雷達利用點雲成型技術能快速獲取大范圍區域表面采樣點的三維空間數據，正是由於其在建模工作上的高效性，因而在 建築規劃、建築施工以及文物保護等 方面起到了重要作用。

2 智能演算法對於圖像技術在智慧建築領域發展的影響

2.1 智能演算法在圖像處理技術中的發展

智能演算法自提出以來就引起了國內外眾多學者的廣泛關注，經過多年的發展和創造，智能優化演算法已成功應用在國民經濟的各個領域，為生產生活中的許多復雜問題提供了一個高效可行的解決方案，成為了學術領域中一個重要的研究方向。其中比較經典的智能優化演算法有: 遺傳演算法(GA)、蟻群演算法(ACO)、粒子群演算法(PSO)、差分進化演算法(DE)、混合蛙跳演算法(SFLA)、人工蜂群演算法 等。 在圖像處理技術上蟻群演算法和粒子群演算法是最常用的演算法 。

總的來說，智能演算法用於圖像處理技術的優化具有兩個方面的重要作用。 一是基於大數據信息平台的信息匯總數據智能處理分析，引導圖像處理技術的優化和發展; 二是基於大數據技術對於數字信號的處理架構以及模型優化，能夠有效輔助現有圖像處理技術，實現圖像處理技術的快速升級。

2.2 智能演算法和圖像耦合技術對感測建模方法的改進

利用 智能演算法與圖像耦合技術 處理施工過程中火災識別、污染識別、勞務人員安全識別等問題具有高速、便捷等特點。智能演算法與圖像之間的耦合技術主要利用圖像本身具有的張量結構，且張量結構具有良好的表達能力和計算特性，因此可以利用智能演算法對張量結構進行分解並快速而高質量對圖像進行壓縮和提取相關特徵信息，從而可以利用獲取的信息進行快速的感測建模。施工現場的大氣污染防治作為建築工地的重要工作之一，利用圖像處理技術對施工過程中的揚塵、裸土覆蓋等問題進行智能識別，通過智能演算法與圖像之間的耦合技術對施工現場的揚塵、煙霧、裸土等信息進行提取感測建模，實現快速識別、抓取、處理等功能，並生成相應的數學模型對施工過程進行預測、評估等，指導施工現場管理。

然而，智能演算法與圖像耦合技術的感測建模方法僅僅是獲取圖像中的 二維數據信息 進行快速建模，對施工現場出現的問題作出的響應更多隻是簡單提取建模、分析、以及預警等，很難進一步提高精度。因此， 智能演算法與圖像之間的耦合技術應結合三維技術進行更加精確的數據信息提取，從而形成精度更高的實時反饋、預測模型、評價模型等指導現場施工實現精確識別、預測告警、以及深度治理等功能 。

3 總結和展望

本文主要對圖像感測技術的發展歷程，以及 圖像技術、視頻技術、激光雷達點雲技術 在建築中的應用進行了概述，指出隨著建築施工過程的日益復雜，建築體量增大，僅僅依靠圖像識別技術對勞務人員、安全帽佩戴、煙霧情況進行識別已經無法滿足工地現場管理的要求，因此目前圖像技術應與視頻技術相結合，以提高圖像識別的准確性。並提出利用激光雷達點雲與視頻圖像技術對施工過程中的揚塵、裸土識別等進行交叉驗證，以提高識別精度，實現建築施工污染源的精準定位、智能預測、深度治理。文中還對智能演算法、以及其在圖像處理技術領域的應用進行了介紹，提出智能演算法與圖像耦合技術對於感測建模方法應結合三維技術進行更加精確的數據信息提取，從而形成精度更高的實時反饋、各類模型等指導現場工地施工。

『玖』 李俊傑的出版著作和論文

部分代表性論文如下： [1] Fei Kang, Junjie Li. Artificial bee colony algorithm optimized support vector regression for system reliability analysis of slopes. Journal of Computing in Civil Engineering, ASCE, 2015, Accepted. (SCI&EI)
[2] Fei Kang, Shaoxuan Han, Rodrigo Salgado, Junjie Li. System probabilistic stability analysis of soil slopes using Gaussian process regression with Latin hypercube sampling. Computers and Geotechnics
[3] Haojin Li, Junjie Li, Fei Kang. Application of the artificial bee colony algorithm-based projection pursuit method in statistical rock mass stability estimation. Environmental Earth Sciences
[4] Fei Kang, Junjie Li, Haojin Li, Artificial bee colony algorithm and pattern search hybridized for global optimization, Applied Soft Computing Top 25 Hottest Articles
[5] Fei Kang, Junjie Li, Zhenyue Ma. An artificial bee colony algorithm for locating the critical slip surface in slope stability analysis. Engineering Optimization
[6] Fei Kang, Junjie Li, Qing Xu. Damage detection based on improved particle swarm optimization using vibration data. Applied Soft Computing
[7] Fei Kang, Junjie Li, Zhenyue Ma. Rosenbrock artificial bee colony algorithm for accurate global optimization of numerical functions. Information Sciences,(SCI&EI) Most Cited Articles since 2010; Top 25 Hottest Articles
[8] Haojin Li, Junjie Li, Fei Kang. Risk analysis of dam based on artificial bee colony algorithm with fuzzy c-means clustering. Canadian Journal of Civil Engineering
[9] Zhou Hui, Li Jun-jie, Kang Fei. Distribution of acceleration and empirical formula for calculating maximum acceleration of rockfill dams. Journal of Central South University of Technology
[10] Fei Kang, Junjie Li, Qing Xu. Structural inverse analysis by hybrid simplex artificial bee colony algorithms. Computers & Structures, (SCI&EI) Most Cited Articles since
[11] Fei Kang, Junjie Li, Qing Xu. Virus coevolution partheno-genetic algorithms for optimal sensor placement. Advanced Engineering Informatics
[12] Wei Zeng, Junjie Li, and Fei Kang, Numerical Manifold Method with Endochronic Theory for Elastoplasticity Analysis, Mathematical Problems in Engineering
[13] Fei Kang, Junjie Li, Sheng Liu. Combined data with particle swarm optimization for structural damage detection. Mathematical Problems in Engineering, Volume
[14] Xu Wang, Fei Kang, Junjie Li, Xin Wang. Inverse parametric analysis of seismic permanent deformation for earth-rockfill dams using artificial neural networks. Mathematical Problems in Engineering, Volume [15] 仝宗良, 曾偉, 李俊傑. 基於數值流形法的土質邊坡動力穩定性分析. 岩土工程學報
[16] 汪旭, 康飛, 李俊傑. 土石壩地震永久變形參數反演方法研究. 岩土力學
[17] 李浩瑾, 李俊傑, 康飛. 基於 LSSVM 的重力壩地震穩定易損性分析. 振動與沖擊
[18] 李浩瑾, 李俊傑, 康飛, 張勇. 重力壩縱縫非連續接觸的地震反應分析. 大連理工大學學報
[19] 周暉, 李俊傑, 康飛.面板堆石壩壩頂加速度沿壩軸線分布規律.岩土力學
[20] 康飛, 李俊傑, 許青. 混合蜂群演算法及其在混凝土壩動力參數反演中的應用. 水利學報
[21] 康飛, 李俊傑, 許青. 堆石壩材料參數反演的蟻群聚類RBF網路模型. 岩石力學與工程學報
[22] 宋志宇，李俊傑，汪宏宇. 混沌人工魚群演算法在重力壩材料參數反演中的應用. 岩土力學
[23] 宋志宇，李俊傑. 基於微粒群演算法的大壩材料參數反分析研究. 岩土力學
[24] 胡軍, 李俊傑, 劉德志. 考慮剪切抗力的修正土釘單元及其應用. 岩土力學
[25] 劉德志, 李俊傑. 大壩安全監測資料的非線性檢驗, 應用基礎與工程科學學報
[26] 劉德志, 李俊傑. 土石壩安全監測軟體系統設計與實現，大連理工大學學報
[27] 楊清平, 李俊傑. 重力壩壩踵主拉應力區分布規律的探討，水利學報
[28] 李俊傑，邵龍潭，邵宇. 面板堆石壩永久變形研究，大連理工大學學報
[29] 李俊傑, 馬恆春. 蓄水期面板堆石壩動力特性研究. 岩土工程學報
[30] 李俊傑, 韓國城, 林皋. 混凝土面板堆石壩自振周期簡化公式. 振動工程學報
[31] 李俊傑, 韓國城, 孔憲京. 關門山面板堆石壩三維地震反應分析. 水利學報
[32] 李俊傑, 孔憲京, 韓國城. 面板堆石壩動力破壞計算方法研究. 大連理工大學學報
[33] 李俊傑, 韓國城, 林皋. 混凝土面板堆石壩地震加速度反應規律的幾點研究. 水利學報
[34] 孔憲京, 韓國城, 李俊傑. 關門山面板堆石壩二維地震反應分析. 大連理工大學學報
[35] 韓國城, 孔憲京, 李俊傑. 面板堆石壩動力破壞性態及抗震措施試驗研究. 水利學報
[36] 孔憲京，韓國城，李俊傑，林皋. 防滲面板對堆石壩體自振特性的影響，大連理工大學學報 [37] 楊春雨, 李俊傑. 改進的 SSOR-PCG 快速求解法在高面板堆石壩求解效率和節約內存中的實踐. 水電能源科學,
[38] 曾偉, 李俊傑. 基於 NMM-DDA 的直剪試驗數值模擬. 水電能源科學
[39] 劉景, 李俊傑. 不同開度時溢流壩弧形閘門水流三維數值模擬. 水電能源科學
[40] 曾偉, 李俊傑. 基於數值流形法的土石壩靜力計算數值模擬. 水利水電技術
[41] 宋宜祥, 李俊傑, 康飛. 虹吸井對尾礦壩地震液化的影響分析. 水電能源科學
[42] 康飛, 李俊傑, 馬震岳. 基於人工蜂群演算法的邊坡最危險滑動面搜索. 防災減災工程學報
[43] 楊秀萍, 李俊傑, 康飛. 基於 ACC-RBF 的水布埡面板堆石壩參數反演分析. 水電自動化與大壩監測
[44] 李浩瑾, 李俊傑, 康飛. 基於 ABCA-LSSVM 的復雜工程結構可靠度計算. 水電能源科學
[45] 康飛, 李俊傑, 馬震岳. 邊坡穩定分析的差分進化全局求解. 水電能源科學
[46] 杜文才, 李俊傑. 貯灰壩安全預警模型研究. 水電能源科學
[47] 李浩瑾, 李俊傑, 康飛. 基於 PSO-AHP 的大壩致災因子權重計算. 防災減災工程學報
[48] 胡崢嶸, 李俊傑. 面板堆石壩三維非線性有限元並行計算. 力學與實踐
[49] 康飛，李俊傑，許青，張運花. 改進人工蜂群演算法及其在反演分析中的應用. 水電能源科學
[50] 張運花，李俊傑，康飛. 西龍池面板堆石壩應力變形三維有限元分析. 水電能源科學，第
[51] 宋志宇，李俊傑. 基於模擬退火神經網路模型的岩質邊坡穩定性評價方法. 長江科學院院報
[52] 李俊傑，胡軍，康飛，王誼. 大頂子山溢流壩長閘墩溫度應力模擬計算分析. 水電能源科學
[53] 康飛，馬妹英，李俊傑. 支持向量回歸在貯灰壩滲流監測中的應用. 水電自動化與大壩監測
[54] 宋志宇，李俊傑. 最小二乘支持向量機在大壩變形預測中的應用. 水電能源科學
[55] 張振國，李俊傑，楊曉明. 基於變分原理的三維土坡穩定分析方法研究及應用. 水電能源科學
[56] 劉德志,李俊傑,許青. 基於Internet-Intranet的火電廠貯灰壩自動化安全監測系統. 水電能源科學
[57] 李俊傑，馬妹英，許青. RBF網路在貯灰壩浸潤線預測中的應用. 水電能源科學
[58] 譚志軍， 李俊傑. 混合遺傳演算法在貯灰壩監測系統上的應用. 水電能源科學
[59] 譚志軍，李俊傑. BP 演算法在貯灰壩監測系統中的應用. 水電自動化與大壩監測
[60] 費璟昊，李俊傑，李輝，楊建林. 利用圖像處理實現隧洞測量. 測繪通報
[61] 李俊傑, 李黎, 許勁松等. 中遠船塢抽水工程監測成果分析. 港口工程