人工智能

人工智能（Artificial Intelligence），英文縮寫為AI。它是研究、開發用于模擬、延伸和擴展人的智能的理論、方法、技術及應用系統的一門新的技術科學。 人工智能是計算機科學的一個分支，它企圖了解智能的實質，并生產出一種新的能以人類智能相似的方式做出反應的智能機器，該領域的研究包括機器人、語言識別、圖像識別、自然語言處理和專家系統等。人工智能從誕生以來，理論和技術日益成熟，應用領域也不斷擴大，可以設想，未來人工智能帶來的科技產品，將會是人類智慧的“容器”。
人工智能是對人的意識、思維的信息過程的模擬。人工智能不是人的智能，但能像人那樣思考、也可能超過人的智能。


================

文本分類

　　自動文本分類(Automatic Text Categorization),或者簡稱為文本分類,是指計算機將一篇文章歸于預先給定的某一類或某幾類的過程。


　　文本分類是指按照預先定義的主題類別,為文檔集合中的每個文檔確定一個類別.文本分類是文本挖掘的一個重要內容。


　　所謂文本分類,是指對所給出的文本,給出預定義的一個或多個類別標號,對文本進行準確、高效的分類.它是許多數據管理任務的重要組成部分。


　　文本分類是指按預先指定的標準對文檔進行歸類這樣用戶不僅可以方便地瀏覽文檔而且可以通過類別來查詢所需的文檔。


　　文本分類是指在給定的分類體系下,根據文語義元是統計語義方法中的原子,是不可分本的內容自動確
定文本類別的過程.當前的文本割的最小單位,在文本分類中語義元是詞。


　　文本分類（Text categorization）是指在給定分類體系下，根據文本內容自動確定文本類別的過程
．20世紀90年代以前，占主導地位的文本分類方法一直是基于知識工程的分類方法，即由專業人員手工進
行分類．人工分類非常費時，效率非常低．90年代以來，眾多的統計方法和機器學習方法應用于自動文本
分類，文本分類技術的研究引起了研究人員的極大興趣．目前在國內也已經開始對中文文本分類進行研究
，并在信息檢索、Web文檔自動分類、數字圖書館、自動文摘、分類新聞組、文本過濾、單詞語義辨析以
及文檔的組織和管理等多個領域得到了初步的應用．


================

圖像分類

圖像分類，根據各自在圖像信息中所反映的不同特征，把不同類別的目標區分開來的圖像處理方法。它利
用計算機對圖像進行定量分析，把圖像或圖像中的每個像元或區域劃歸為若干個類別中的某一種，以代替
人的視覺判讀。


分類方法
基于色彩特征的索引技術
色彩是物體表面的一種視覺特性,每種物體都有其特有的色彩特征,譬如人們說到綠色往往是和樹木或草原
相關,談到藍色往往是和大?；蛩{天相關,同一類物體往拍幾有著相似的色彩特征,因此我們可以根據色彩
特征來區分物體.用色彩特特征進行圖像分類一可以追溯到Swain和Ballard提出的色彩直方圖的方法.由于
色彩直方圖具有簡單且隨圖像的大小、旋轉變化不敏感等特點,得到了研究人員的廠泛關注,目前幾乎所有
基于內容分類的圖像數據庫系統都把色彩分類方法作為分類的一個重要手段,并提出了許多改進方法,歸納
起主要可以分為兩類：全局色彩特征索引和局部色彩特征索引。


基于紋理的圖像分類技術
紋理特征也是圖像的重要特征之一,其本質是刻畫象素的鄰域灰度空間分布規律由于它在模式識別和計算
機視覺等領域已經取得了豐富的研究成果,因此可以借用到圖像分類中。
在70年代早期,Haralick等人提出紋理特征的灰度共生矩陣表示法(eo一oeeurrenee matrix?
representation),這個方法提取的是紋理的灰度級空間相關性(gray level Spatial dependenee),它首先
基于象素之間的距離和方向建立灰度共生矩陣,再由這個矩陣提取有意義的統計量作為紋理特征向量?；?
于一項人眼對紋理的視覺感知的心理研究,Tamuar等人提出可以模擬紋理視覺模型的6個紋理屬性,分別是
粒度,對比度,方向性,線型,均勻性和粗糙度。QBIC系統和MARS系統就采用的是這種紋理表示方法。
在90年代初期,當小波變換的理論結構建一認起來之后,許多研究者開始研究
如何用小波變換表示紋理特征。smiht和chang利用從小波子帶中提取的統計量(平均值和方差)作為紋理特
征。這個算法在112幅Brodatz紋理圖像中達到了90%的準確率。為了利用中間帶的特征,Chang和Kuo開發出
一種樹型結構的小波變化來進一步提高分類的準確性。還有一些研究者將小波變換和其他的變換結合起來
以得到更好的性能,如Thygaarajna等人結合小波變換和共生矩陣,以兼顧基于統計的和基于變換的紋理分
析算法的優點。


基于形狀的圖像分類技術
形狀是圖像的重要可視化內容之一在二維圖像空間中,形狀通常被認為是一條封閉的輪廓曲線所包圍的區
域,所以對形狀的描述涉及到對輪廓邊界的描述以及對這個邊界所包圍區域的描述.目前的基于形狀分類方
法大多圍繞著從形狀的輪廓特征和形狀的區域特征建立圖像索引。關于對形狀輪廓特征的描述主要有:直
線段描述、樣條擬合曲線、傅立葉描述子以及高斯參數曲線等等。
實際上更常用的辦法是采用區域特征和邊界特征相結合來進行形狀的相似分類.如Eakins等人提出了一組
重畫規則并對形狀輪廓用線段和圓弧進行簡化表達,然后定義形狀的鄰接族和形族兩種分族函數對形狀進
行分類.鄰接分族主要采用了形狀的邊界信息,而形狀形族主要采用了形狀區域信息.在形狀進行匹配時,除
了每個族中形狀差異外,還比較每個族中質心和周長的差異,以及整個形狀的位置特征矢量的差異,查詢判
別距離是這些差異的加權和。


基于空間關系的圖像分類技術
在圖像信息系統中,依據圖像中對象及對象間的空間位置關系來區別圖像庫中的不同圖像是一個非常重要
的方法。因此,如何存貯圖像對象及其中對象位置關系以方便圖像的分類,是圖像數據庫系統設計的一個重
要問題。而且利用圖像中對象間的空間關系來區別圖像,符合人們識別圖像的習慣,所以許多研究人員從圖
像中對象空間位置關系出發,著手對基于對象空間位置關系的分類方法進行了研究。早在1976年,Tanimoto
提出了用像元方法來表示圖像中的實體,并提出了用像元來作為圖像對象索引。隨后被美國匹茲堡大學
chang采納并提出用二維符號串(2D一String)的表示方法來進行圖像空間關系的分類,由于該方法簡單,并
且對于部分圖像來說可以從ZD一String重構它們的符號圖,因此被許多人采用和改進,該方法的缺點是僅用
對象的質心表示空間位置;其次是對于一些圖像來
說我們不能根據其ZD一string完個重構其符號圖;再則是上述的空間關系太簡單,實際中的空間關系要復雜
得多。,針對這些問題許多人提出了改進力一法。Jungert根據圖像對象的最小包圍盒分別在:x軸方向和y
軸上的投影區間之間的交疊關系來表示對象之間的空間關系,隨后Cllallg和Jungert等人又提出了廣義ZD
一string(ZDG一String)的方法,將圖像對象進一步切分為更小的子對象來表示對象的空間關系,但是該方
法不足之處是當圖像對象數日比較多且空間關系比較復雜時,需要切分的子對象的數目很多,存儲的開銷太
大,針對此Lee和Hsu等人提出了ZDC一string的方一法,它們采用Anell提出的13種時態間隔關系并應用到空
間投影區問上來表達空間關系。在x軸方向和y軸方向的組合關系共有169種,他提出了5種基本關系轉換法
則,在此基礎上又提出了新的對象切分方法。采用
ZDC一string的方法比ZDG一string切分子對象的數目明顯減少。為了在空間關系中保留兩個對象的相對空
間距離和對象的大小,Huang等人提出了ZDC書string的方法提高符號圖的重構精度,并使得對包含對象相對
大小、距離的符號圖的推理成為可能。上述方法都涉及到將圖像對象進行劃分為子對象,且在用符號串重
構對象時處理時間的開銷都比較大,為解決這些方法的不足,Lee等人又提出了ZDB一String的方法,它不要
求對象進一步劃分,用對象的名稱來表示對象的起點和終點邊界。為了解決符號圖的重構問題,Chin一
ChenCllang等人提出了面向相對坐標解決符號圖的重構問題,Chin一ChenChang等人提出了面向相對坐標符
號串表示(RCOS串),它們用對象最小外接包圍盒的左下角坐標和右上角坐標來表示對象之間的空間關系.
對于對象之間的空間關系采用Allen提出的13種區間表示方法。實際上上述所有方法都不是和對象的方位
無關,為此Huang等人又提出了RSString表示方法。雖然上述各種方法在對圖像對象空間信息的分類起到過
一定作用,由于它們都是采用對象的最小外接矩形來表示一個對象空間位置,這對于矩形對象來說是比較合
適的,但是當兩個對象是不規則形狀,且它們在空間關系上是分離時,它們的外接矩形卻存在著某種包含和
交疊,結果出現對這些對象空間關系的錯誤表示。用上述空間關系進行圖像分類都是定性的分類方一法,將
圖像的空間關系轉換為圖像相似性的定量度量是一個較為困難的事情。Nabil綜合ZD一String方法和二維
平面中對象之間的點集拓撲關系。提出了ZD一PIR分類方法,兩個對象之間的相似與否就轉換為兩個圖像的
ZD一PIR圖之間是否同構。ZD一PIR中只有圖像對象之間的空間拓撲關系具有旋轉不變性,在進行圖像分類
的時候沒有考慮對象之間的相對距離。

圖像空間
圖像空間的分類方法—利用圖像的灰度,顏色,紋理,形狀,位置等底層特征對圖像進行分類;例如:
[1]利用灰度直方圖特征對圖像進行分類;
[2]利用紋理特征對圖像進行分類;
[3]采用紋理,邊緣和顏色直方圖混合特征對圖像進行分類 ;
[1],[2],[3]均采用SVM作為分類器.
[4]用矩陣表示圖像,矩陣元素是相應象素的灰度值,然后用SVD和PCA方法抽取圖像特征,BP網絡作為分類器
.
圖像空間的分類方法的共同缺點是數據量大,計算復雜性高,但分類精度一般比較理想.


特征空間
特征空間的分類方法—首先將原圖像經過某種變換如K-L變換,小波變換等變換到特征空間,然后在特征空
間提取圖像的高層特征以實現圖像的分類.這類分類方法尤以紋理圖像分類和遙感圖像分類最多.以下是常
見的紋理分類方法,基本上都用到了高波過濾器。
[1]Support vector machine classifier Gabor filters and wavelet transform;
[2]Multiple neural network classifiers Gabor filters;
[3]Bayesian network classifier Gabor filters and Statistical features;
[4]Support vector machine classifier Gabor filters
特征空間的分類方法可降低數據維數,降低計算復雜性,但問題相關性較強,與特征提取的方法和效果有很大關系.


================

兩種圖像分類算法和matlab源代碼

文章主要內容：
第一種圖像分類算法：
極光作為太陽風與地球磁層相互作用產生的典型電離層蹤跡,其形態和變化過程對研究空間天氣活動極為
重要。日側冕狀極光作為極光一種重要形態,能夠反映磁正午時期太陽風和地球磁層相互作用的過程。因
此,研究各類日側冕狀極光對分析空間天氣活動,電離層及其動態特征具有重要意義。本文提出了一種新的
基于靜態極光圖像分類的極光特征提取方法,利用X-GLAMs提取極光原始圖像的紋理特征。結合極光紋理特
點,X-GLAM選取典型鄰域點組成新的鄰域機制。在分類階段,利用支持向量機(SVM)學習極光紋理類別模型,
然后將給定的極光紋理特征分類到之前學習的類別模型中去。實驗結果顯示,基于X-GLAMs特征的日側極光
圖像分類算法在處理復雜的冕狀極光時獲得了很好的效果。針對大規模待處理的極光樣本數據,本文提出
了一種基于特征選擇的日側極光分類算法。為了降低噪聲影響并解決特征維度過高的問題,引入ReliefF算
法對X-GLAMs特征進行選擇,進一步篩選出有效的特征向量。本文提出的特征選擇方法在保證計算精度的前
提下,一定程度上減小了實驗運行速度,為大規模處理極光樣本數據創造了基礎。

第二種圖像分類算法：


極化SAR能夠同時獲得目標區域的多通道與高分辨率數據,可更好的揭示目標的物理散射特性,因此,極化
SAR圖像的特征提取與目標分類在解釋雷達圖像和目標識別方面起著十分重要的作用。充分利用極化信息,
可更加準確地理解目標散射機理,從而帶來更好的SAR圖像分類結果。本文根據極化SAR數據的特點,結合子
孔徑分析技術,進行了極化SAR圖像目標分類算法的研究,主要工作如下:1.總結了目前常用的極化SAR圖像
分類算法及其存在的問題。在此基礎上,將AdaBoost算法與極化通道所攜帶的信息相結合,對極化SAR圖像
進行監督分類,在已知場景類別數的情況下,該方法能夠加快收斂速度,改善分類效果;2.研究了基于子孔徑
分析的極化散射機理與特征提取方法。首先從時頻分解的角度對方位向子孔徑進行了分析,對場景中存在
的各向異性散射行為和布拉格諧振現象進行了討論。針對場景中的非平穩目標,分析了已有的極大似然比
非平穩目標檢測算法,還研究了一種基于熵值與平均散射機理角的聯合向量檢測非平穩目標的方法。通過
該方法可以對方位向頻譜中的非平穩散射行為進行定位,最終消除非平穩散射在全孔徑中的影響;3.對目標
的極化分解方法與基于極化分解的極化SAR圖像分類方法進行了研究與仿真試驗。如Pauli分解、Krogager
分解、H/α分類、H/A/α分類、H/α/Wishart分類、H/A/α/Wishart分類和基于Freeman-Wishart的極化
SAR圖像分類等。在此基礎上,改進了基于AdaBoost算法的極化SAR圖像分類方法,將Pauli分解與AdaBoost
算法的優勢得以發揮,該方法既解決了AdaBoost算法需要知道場景先驗知識的缺點,同時還能改善分類效果
、提高收斂速度;4.改進了基于全孔徑數據的極化SAR圖像分類方法,得到三種基于子孔徑的極化SAR圖像分
類算法并進行了仿真試驗:一是非平穩目標檢測與H/α分類相結合的極化SAR圖像分類;二是子孔徑分解與
H/α/Wishart迭代分類相結合的極化SAR圖像分類;三是結合Freeman分解與子孔徑散射特性的極化SAR圖像
分類。仿真試驗表明,結合子孔徑分析與極化分解的極化SAR圖像分類,能夠在一定程度上改善分類效果、
增加分類精細度、提高收斂速度,在實際的SAR圖像分類應用中具有很大的價值。


matlab主程序：
function [BESTX,BESTY,ALLX,ALLY]=ImageClassify(K,N,Pm,LB,UB,D,c,m)
% 輕風論文網原創作品，轉載請注明
M=length(LB);
farm=zeros(M,N);
for i=1:M
x=unifrnd(LB(i),UB(i),1,N);
farm(i,:)=x;
end
ALLX=cell(K,1);
ALLY=zeros(K,N);
BESTX=cell(K,1);
BESTY=zeros(K,1);
k=1;
while k<=K
newfarm=zeros(M,2*N);
Ser=randperm(N);
A=farm(:,Ser(1));
B=farm(:,Ser(2));
P0=unidrnd(M-1);
a=[A(1:P0,:);B((P0+1):end,:)];
b=[B(1:P0,:);A((P0+1):end,:)];
newfarm(:,2*N-1)=a;
newfarm(:,2*N)=b;
for i=1:(N-1)
A=farm(:,Ser(i));
B=farm(:,Ser(i+1));
P0=unidrnd(M-1);
a=[A(1:P0,:);B((P0+1):end,:)];
b=[B(1:P0,:);A((P0+1):end,:)];
newfarm(:,2*i-1)=a;
newfarm(:,2*i)=b;
end
FARM=[farm,newfarm];
SER=randperm(3*N);
FITNESS=zeros(1,3*N);
fitness=zeros(1,N);
for i=1:(3*N)
Beta=FARM(:,i);
FITNESS(i)=FIT(Beta,D,c,m);
end
for i=1:N
f1=FITNESS(SER(3*i-2));
f2=FITNESS(SER(3*i-1));
f3=FITNESS(SER(3*i));
if f1<=f2&&f1<=f3
farm(:,i)=FARM(:,SER(3*i-2));
fitness(:,i)=FITNESS(:,SER(3*i-2));
elseif f2<=f1&&f2<=f3
farm(:,i)=FARM(:,SER(3*i-1));
fitness(:,i)=FITNESS(:,SER(3*i-1));
else
farm(:,i)=FARM(:,SER(3*i));
fitness(:,i)=FITNESS(:,SER(3*i));
end
end
X=farm;
Y=fitness;
ALLX{k}=X;
ALLY(k,:)=Y;
minY=min(Y);
pos=find(Y==minY);
BESTX{k}=X(:,pos(1));
BESTY(k)=minY;
for i=1:N
if Pm>rand&&pos(1)~=i
AA=farm(:,i);
BB=GM(AA,LB,UB);
farm(:,i)=BB;
end
end


================

機器視覺產品農業應用

? ? 自動化產業的迅猛發展，帶動了機器視覺產品在各個行業領域內的應用；農業是我國生存之本，怎樣
更好的提高農業生產效率及生產質量，一直是國家領導人關心的頭等問題，


? ? 機器視覺產品在農業生產中的應用主要有：?


? ?1、瓜果品質的無損檢測中的應用；通過圖像采集卡，采集瓜果的形態，顏色等特征，將采集結果傳送
給分析處理系統，根據處理結果判斷瓜果是否為有損產品。?


? ?2、烤煙煙葉質量檢測中的應用；對大量煙葉樣本進行顏色分析，可得到各類樣本顏色特征值的分布情
況，采用輪廓跟蹤算法對煙葉的整體圖像外型輪廓進行提取，采用鏈碼表示法進行描述。最后通過煙葉對
光的透過特性對葉片結構和身份特征進行綜合提取和描述。?


? 3、谷物識別與分級中的應用；對大米、小麥、玉米以及其他谷物的識別和分級，例如根據應力裂紋、
形態、染色后顏色特征等，應用神經網絡、高速濾波等技術來進行識別和分類。?


? 4、農副產品的出廠質量檢測，如包裝、缺損，對肉類、各種農副產品、蔬菜、瓜果產品的出廠包裝、
質量合格檢測等。?


? 5、在農業機械中的應用；農產品分選機械是機器視覺技術在農業機械中應用最早、最多的一個方面，
主要是利用該項技術進行無損檢測，即利用農產品表面所反映出的一些基本物理特性對產品按—定的標準
進行質量評估和分級。主要用于在農產品加工過程中進行品質自動檢測及反饋控制。?


? 6、機器視覺技術在農業生產自動化中的應用；在動植物的生長過程中，根據對其生長情況的精確自動
地進行監測，可以有效的控制動植物的生長環境，以滿足動植物生產所需。?


? ? 機器視覺在農業方面的應用檢測還有很多，由于我國是人口大國，以農業為基礎，許多專家致力于農
業生產方面的研究，機器視覺在農業機械方面的應用已取得了長足的進步；在國內，又以陜西維視數字圖
像技術有限公司生產的機器視覺產品盛名，其在視覺檢測、測量、圖像識別、視覺定位等方面具有領先水
平，生產的產品如圖像采集卡，流媒體采集卡，VGA采集卡等都在農業檢測方面取得了良好的成績，備受
用戶青睞。


================

五大最成功人工智能技術應用

電腦“深藍”擊敗國際象棋第一人


所謂人工智能，就是要實現所有目前還無法不借助人類智慧才能實現的任務的集合?；蛟S“人工智能”聽起來總讓人想起科幻小說或者科幻電影中的那些聰明的robot，很有趣，但卻缺乏真實感。可實際上機器人外形只不過是人工智能的容器之一，人工智能很早之前就以多種形態出現在生活之中。


沃森：擊敗最強大腦的人工智能


如果說深藍只體現于對弈的人工智能并不算足夠智能的話，那么另一款人工智能程序“沃森”，則能夠符合大眾對“智能”的認知。在一檔類似于“最強大腦”的綜藝節目《危險邊緣》中，沃森擊敗了兩位最高紀錄保持者，獲得百萬獎金。問答過程中，沃森在無人類協助的情況下，獨自完成對自然語言的分析，并且以遠超人類的速度完成搶答。


人工智能程序沃森的特點在于對大數據迅速、準確的分析，于是現今IBM正將其運用于醫學領域。病人向沃森上傳自己的病況與癥狀，沃森則根據該情況分析患者最有可能患上的疾病種類，并提供醫治方法。今后該程序還可運用在更多特定環境中，為用戶提供各種緊急情況的應對方法。


谷歌搜索：隱藏最深的人工智能


2002年，尚未成為谷歌CEO的拉里·佩奇曾在回答凱文·凱利“為什么谷歌要做免費搜索”的提問時，回答道，“不，我們在做人工智能”。實際上，谷歌搜索正是一種完善人工智能的嘗試：用戶在谷歌上的每一次搜索，都是在輔導人工智能進行深度學習。




谷歌搜索在表面上只是一款搜索引擎，但其引擎的機理和很多人工智能程序相同：以并行計算、大數據及更深層次算法為基礎，完成對數據、問題的智能化分析?；蛟S很多谷歌用戶都能感受到，谷歌搜索正變得越來越“聰明”，越來越“懂你”，而賦予其這種學習能力的，正是人工智能。


谷歌無人駕駛汽車：即將到來的人工智能


前方紅燈需要停車；左轉彎時注意行人與后方汽車；前方汽車急停需要迅速踩剎車……諸如此類復雜且參考因素眾多的駕駛問題，只有人類才能妥善解決。不過這個情況馬上就會迎來改變，因為Google的無人駕駛車將于2020年正式上市。人工智能正在取代人類的工作，解放人類的雙手。




與谷歌無人駕駛汽車高價值對應的，是復雜的分析程式：利用傳感器、雷達、攝像機、激光測距儀、GPS等獲得路況信息，再交由系統分析，獲得應對措施，再傳達至汽車的各項零部件……其復雜繁瑣程度可見一斑。雖然谷歌汽車暫時尚未能完全實現汽車自動駕駛，但相信隨著人工智能技術的發展，人工智能完全接替人力操作的未來并不遙遠。


QVM：最安全也&最冷門的人工智能


國內也有頗多廠商開始利用人工智能技術為大眾服務，其中成熟度較高的則是安全領域中的一款殺毒引擎：360 QVM引擎。QVM引擎在病毒庫中尋找病毒演化規律并歸納成算法，爾后利用人工智能技術的學習功能將其掌握，最終QVM引擎將能夠自主識別病毒庫中的樣本及病毒庫中并不存在的樣本“進化版”。據了解，人工智能引擎QVM被歸為第三代殺毒引擎，其病毒檢出率已遠超前兩代引擎的總和，且查殺速度至少提高一倍。


在反病毒領域，QVM的價值并不僅體現在其快速、準確的識別、查殺病毒能力，還有將人工智能技術與殺毒軟件結合的想法：首先通過對病毒樣本的分析和分類形成樣本向量和向量機，然后建立一個機器學習的決策機模型，利用決策樹和向量機對大量樣本進行學習，從而識別惡意程序或非惡意程序；并且病毒庫中的樣本越多，QVM引擎的查殺將越快、越精確。運用人工智能技術的QVM引擎，正在重新定義殺毒軟件的歷史。


蘋果Siri：為你解決問題的人工智能


相比于冷冰冰的的病毒引擎，人們對有“感情”的Siri明顯更有興趣。Siri用到的技術同樣基于人工智能以及云計算：通過與用戶交互獲取用戶需求，將自然語言轉化為“真實含義”，交由知識庫分析、檢索所需結果，最終再轉換為自然語言回答給用戶。短短數秒之內，Siri就能將用戶需求轉化為多不同的表述方式并完成在海量數據中的搜索。


Siri對人類生活產生的影響無需贅述，從最初的聊天解悶，到后來能有效的幫助主人搜索并解決問題，現今Siri儼然成為最合格的“私人助理”。在并不遙遠的未來，以Siri為代表的人工智能語音識別技術亦將有著更大的發展：類似于“沃森”的醫療求助、車載導航乃至教育領域都可以利用該技術來達到解放人力的目的。


================

人工智能基本方法及程序設計

第1章狀態圖搜索?
　　1.1狀態圖?
　　1.2狀態圖搜索方式?
　　1.3狀態圖搜索算法?
　　1.4狀態圖搜索程序設計?


　　第2章樹式狀態圖搜索?
　　2.1窮舉式搜索?
　　2.2啟發式搜索?


　　第3章加權狀態圖搜索?
　　3.1加權狀態圖與代價樹?
　　3.2最小代價優先法?
　　3.3 A與A算法?


　　第4章與或圖搜索?
　　4.1與或圖?
　　4.2與或圖搜索?


　　第5章博弈樹搜索?
　　5.1博弈的基本概念?
　　5.2博弈樹的基本概念?
　　5.3極小極大搜索法?
　　5.4一字棋游戲?


　　第6章遺傳算法?
　　6.1遺傳算法中相關基本概念?
　　6.2遺傳操作?
　　6.3基本遺傳算法?
　　6.4遺傳算法應用舉例?
　　6.5遺傳算法程序設計?


　　第7章基于產生式規則的機器推理?
　　7.1產生式規則?
　　7.2產生式系統?
　　7.3簡單的產生式系統程序設計?


　　第8章決策樹學習?
　　8.1機器學習概述?
　　8.2決策樹學習概述?
　　8.3 ID3算法?
　　8.4 ID3算法程序設計?


　　第9章神經網絡學習?
　　9.1神經網絡概述?
　　9.2神經網絡學習概述?
　　9.3 BP神經網絡?
　　9.4 BP算法程序設計?


================

人工智能算法實現：A*算法c語言

A*算法，A*（A-Star)算法是一種靜態路網中求解最短路最有效的方法。估價值與實際值越接近，估價函數取得就越好。


A*[1]（A-Star)算法是一種靜態路網中求解最短路最有效的方法。


公式表示為： f(n)=g(n)+h(n),


其中 f(n) 是從初始點經由節點n到目標點的估價函數，


g(n) 是在狀態空間中從初始節點到n節點的實際代價，


h(n) 是從n到目標節點最佳路徑的估計代價。


保證找到最短路徑（最優解的）條件，關鍵在于估價函數h(n)的選取：


估價值h(n)<= n到目標節點的距離實際值，這種情況下，搜索的點數多，搜索范圍大，效率低。但能得到最優解。


如果 估價值>實際值,搜索的點數少，搜索范圍小，效率高，但不能保證得到最優解。




方法/步驟
估價值與實際值越接近，估價函數取得就越好
例如對于幾何路網來說，可以取兩節點間歐幾理德距離（直線距離）做為估價值，即f=g(n)+sqrt((dx-nx)*(dx-nx)+(dy-ny)*(dy-ny))；這樣估價函數f在g值一定的情況下，會或多或少的受估價值h的制約，節點距目標點近，h值小，f值相對就小，能保證最短路的搜索向終點的方向進行。明顯優于Dijkstra算法的毫無方向的向四周搜索。
conditions of heuristic
Optimistic (must be less than or equal to the real cost)
As close to the real cost as possible
詳細內容：
創建兩個表，OPEN表保存所有已生成而未考察的節點，CLOSED表中記錄已訪問過的節點。
算起點的估價值;
將起點放入OPEN表;


A star算法在靜態路網中的應用，以在地圖中找從開始點 s 到e點的最短行走路徑為例：
首先定義數據結構
#define MAPMAXSIZE 100 //地圖面積最大為 100x100?
#define MAXINT 8192 //定義一個最大整數, 地圖上任意兩點距離不會超過它?
#define STACKSIZE 65536 //保存搜索節點的堆棧大小?
#define tile_num(x,y) ((y)*map_w+(x)) //將 x,y 坐標轉換為地圖上塊的編號?
#define tile_x(n) ((n)%map_w) //由塊編號得出 x,y 坐標?
#define tile_y(n) ((n)/map_w)?
// 樹結構, 比較特殊, 是從葉節點向根節點反向鏈接?
typedef struct node *TREE;?
struct node {
int h;
int tile;
TREE father;
};
typedef struct node2 *LINK;
struct node2 {
TREE node;
int f;
LINK next;
};
LINK queue; // 保存沒有處理的行走方法的節點?
TREE stack[STACKSIZE]; // 保存已經處理過的節點 (搜索完后釋放)?
int stacktop;
char map[][6]={{'x','x','x','x','x','x'},
? ? ? ? ? ? ? ?{'x','e',' ',' ',' ','x'},
? ? ? ? ? ? ? ?{'x','x',' ','x',' ','x'},
? ? ? ? ? ? ? ?{'x','x',' ',' ',' ','x'},
? ? ? ? ? ? ? ?{'x','x','x','x','s','x'},
? ? ? ? ? ? ? ?{'x','x','x','x','x','x'} };//地圖數據?
int dis_map[MAPMAXSIZE][MAPMAXSIZE];//保存搜索路徑時,中間目標地最優解?
int map_w,map_h;//地圖寬和高?
int start_x,start_y,end_x,end_y; //地點,終點坐標?
// 路徑尋找主函數?
void findpath(int *path)
{
?//printf("%d,%d,%d,%d",start_x,start_y,end_x,end_y); ?
TREE root;
int i,j;
stacktop=0;
for (i=0;i<map_h;i++)
for (j=0;j<map_w;j++)
dis_map[i][j]=MAXINT;
init_queue();
root=(TREE)malloc(sizeof(*root));
root->tile=tile_num(start_x,start_y);
root->h=0;
root->father=NULL;
enter_queue(root,judge(start_x,start_y));
for (;;) {
int x,y,child;
TREE p;
root=get_from_queue();
if (root==NULL) {
*path=-1;
return;
}
x=tile_x(root->tile);
y=tile_y(root->tile);
if (x==end_x && y==end_y) break;// 達到目的地成功返回?
child=trytile(x,y-1,root);//嘗試向上移動?
child&=trytile(x,y+1,root);//嘗試向下移動?
child&=trytile(x-1,y,root);//嘗試向左移動?
child&=trytile(x+1,y,root);//嘗試向右移動?
if (child!=0)
pop_stack();// 如果四個方向均不能移動,釋放這個死節點?
}
// 回溯樹，將求出的最佳路徑保存在 path[] 中?
for (i=0;root;i++) {
path[i]=root->tile;
root=root->father;
//printf("pathis %d",path[i]);
}
path[i]=-1;
freetree();
}
// 估價函數,估價 x,y 到目的地的距離,估計值必須保證比實際值小?
int judge(int x,int y)
{?
int distance;
distance=abs(end_x-x)+abs(end_y-y);
return distance;
}
// 嘗試下一步移動到 x,y 可行否?
int trytile(int x,int y,TREE father)
{
TREE p=father;
int h;
if (map[y][x]=='x') return 1; // 如果 (x,y) 處是障礙,失敗?
while (p) {
if (x==tile_x(p->tile) && y==tile_y(p->tile)) return 1; //如果 (x,y) 曾經經過,失敗?
p=p->father;
}
h=father->h+1;
if (h>=dis_map[y][x]) return 1;// 如果曾經有更好的方案移動到 (x,y) 失敗?
dis_map[y][x]=h;// 記錄這次到 (x,y) 的距離為歷史最佳距離?
// 將這步方案記入待處理隊列?
p=(TREE)malloc(sizeof(*p));
p->father=father;
p->h=father->h+1;
p->tile=tile_num(x,y);
enter_queue(p,p->h+judge(x,y));
return 0;
}


打開c語言編譯器，輸入我們的運行代碼，編譯，運行如下，打印出地圖如下圖：
人工智能算法實現：[1]A*算法c語言
人工智能算法實現：[1]A*算法c語言
點任意鍵進行運行找靜態路網
人工智能算法實現：[1]A*算法c語言
人工智能算法實現：[1]A*算法c語言
人工智能算法實現：[1]A*算法c語言
說明：找到路后會存到一個數組中去，我們為了顯示這個過程可以運用打印函數打印出來代碼如下
void printpath(int *path)
{
int i;
//printf("-44444444444444");
for (i=0;path[i]>=0;i++) {
gotoxy(tile_x(path[i])+1,tile_y(path[i])+1);
printf("-");
Sleep(2000); ? ? ? ??
}
printf("\n");
printf("\n");
printf("走迷宮完成");
}
整個程序的代碼如下：
#include<windows.h>
#include"stdio.h"
#include<conio.h>
#include"assert.h"?
#include"stdlib.h"
#define MAPMAXSIZE 100 //地圖面積最大為 100x100?
#define MAXINT 8192 //定義一個最大整數, 地圖上任意兩點距離不會超過它?
#define STACKSIZE 65536 //保存搜索節點的堆棧大小?
#define tile_num(x,y) ((y)*map_w+(x)) //將 x,y 坐標轉換為地圖上塊的編號?
#define tile_x(n) ((n)%map_w) //由塊編號得出 x,y 坐標?
#define tile_y(n) ((n)/map_w)?
// 樹結構, 比較特殊, 是從葉節點向根節點反向鏈接?
typedef struct node *TREE;?
struct/*designde by 1wangxiaobo@163.com*/ node {
int h;
int tile;
TREE father;
};
typedef struct /*designde by 1wangxiaobo@163.com*/node2 *LINK;
struct node2 {
TREE node;
int f;/*designde by 1wangxiaobo@163.com*/
LINK next;
};
LINK queue; // 保存沒有處理的行走方法的節點?
TREE stack[STACKSIZE]; // 保存已經處理過的節點 (搜索完后釋放)?
int stacktop;
char map[][6]={{'x','x','x','x','x','x'},
? ? ? ? ? ? ? ?{'x','e',' ',' ',' ','x'},
? ? ? ? ? ? ? ?{'x','x',' ','x',' ','x'},
? ? ? ? ? ? ? ?{'x','x',' ',' ',' ','x'},
? ? ? ? ? ? ? ?{'x','x','x','x','s','x'},
? ? ? ? ? ? ? ?{'x','x','x','x','x','x'} };//地圖數據?
int dis_map/*designde by 1wangxiaobo@163.com*/[MAPMAXSIZE][MAPMAXSIZE];//保存搜索路徑時,中間目標地最優解?
int map_w,map_h;//地圖寬和高?
int start_x,start_y,end_x,end_y; //地點,終點坐標?
void gotoxy(int x ,int y)
{
HANDLE a;
COORD zb;
zb.X =x-1;
zb.Y =y-1;
a= GetStdHandle(STD_OUTPUT_HANDLE/*designde by 1wangxiaobo@163.com*/);
SetConsoleCursorPosition(a,zb);
}
// 初始化隊列?
void init_queue()
{?
queue=(LINK)malloc(sizeof(*queue));
queue->node=NULL;
queue->f=-1;
queue->next=(LINK)/*designde by 1wangxiaobo@163.com*/malloc(sizeof(*queue));
queue->next->f=MAXINT;
queue->next->node=NULL;
queue->next->next=NULL;
}?
// 待處理節點入隊列, 依靠對目的地估價距離插入排序?
void enter_queue(TREE node,int f)
{?
LINK p=queue,father,q;
while(f>p->f) {
father=p;
p=p->next/*designde by 1wangxiaobo@163.com*/;
assert(p);
}?
q=(LINK)malloc(sizeof(*q));
assert(queue);
q->f=f,q->node=node,q->next=p;
father->next=q;
}?
// 將離目的地估計最近的方案出隊列?
TREE get_from_queue()
{?
TREE bestchoice=queue->next->node;
LINK next=queue->next->next;
/*designde by 1wangxiaobo@163.com*/free(queue->next);
queue->next=next;
stack[stacktop++]=bestchoice;
assert(stacktop<STACKSIZE);
return /*designde by 1wangxiaobo@163.com*/bestchoice;
}?
// 釋放棧頂節點?
void pop_stack()
{?
free(stack[--stacktop]);
}
// 釋放申請過的所有節點?
void freetree()
{?
int i;
LINK p;
for (i=0;i<stacktop;i++)
free(stack);
while /*designde by 1wangxiaobo@163.com*/(queue) {
p=queue;
free(p->node);
queue=queue->next;
free(p);
}?
}?
// 估價函數,估價 x,y 到目的地的距離,估計值必須保證比實際值小?
int judge(int x,int y)
{?
int distance;
distance=abs(end_x-x)+abs(end_y-y);
return distance;
}
// 嘗試下一步移動到 x,y 可行否?
int trytile(int/*designde by 1wangxiaobo@163.com*/ x,int y,TREE father)
{
TREE p=father;
int h;
if (map[y][x]=='x') return 1; // 如果 (x,y) 處是障礙,失敗?
while (p) {
/*designde by 1wangxiaobo@163.com*/if (x==tile_x(p->tile) && y==tile_y(p->tile)) return 1; //如果 (x,y) 曾經經過,失敗?
p=p->father;
}
h=father->h+1;
if (h>=dis_map[y][x]) return 1;// 如果曾經有更好的方案移動到 (x,y) 失敗?
dis_map[y][x]=h;// 記錄這次到 (x,y) 的距離為歷史最佳距離?
// 將這步方案記入待處理隊列?
p=(TREE)malloc(sizeof(*p));
p->father=father;
p->h=father->h+1;
p->tile=tile_num(x,y);
enter_queue(p,p->h+judge(x,y));
return 0;
}
// 路徑尋找主函數?
void findpath(int *path)
{
?//printf("%d,%d,%d,%d",start_x,start_y,end_x,end_y); ?
TREE root;
int i,j;
stacktop=0;
for (i=0;i<map_h;i++)
for (j=0;j<map_w;j++)
dis_map[i][j/*designde by 1wangxiaobo@163.com*/]=MAXINT;
init_queue();
root=(TREE)malloc(sizeof(*root));
root->tile=tile_num(start_x,start_y);
root->h=0;
root->father=NULL;
enter_queue(root,judge(start_x,start_y));
for (;;) {
int x,y,child;
TREE p;
root=get_from_queue();
if (root==NULL) {
*path=-1;
return;
}
x=tile_x(root->tile);
y=tile_y(root->tile);
if (x==end_x && y==end_y) break;// 達到目的地成功返回?
child=trytile(x,y-1,root);//嘗試向上移動?
child&=trytile(x,y+1,root);//嘗試向下移動?
child&=trytile(x-1,y,root);//嘗試向左移動?
child&=trytile(x+1,y,root);//嘗試向右移動?
if (child!=0)
pop_stack();// 如果四個方向均不能移動,釋放這個死節點?
}
// 回溯樹，將求出的最佳路徑保存在 path[] 中?
for (i=0;root;i++) {
path[i]=root->tile;
root=root->father;
//printf("pathis %d",path[i]/*designde by 1wangxiaobo@163.com*/);
}
path[i]=-1;
freetree();
}
void printpath(int *path)
{
int i;
//printf("-44444444444444");
for (i=0;path[i]>=0;i++) {
gotoxy(tile_x(path[i])+1,tile_y(path[i])+1);
printf("-");
Sleep(2000); ? ? ? ??
}
printf("\n");
printf("\n");
printf("走迷宮完成");
}
void readmap()
{ printf("走迷宮，s是起始點 e是終點 ?按任意鍵開始");
getchar();
//FILE *f;
int i,j;
//f=fopen("2.c","r");
//assert(f);
//scanf("%d%d",&map_w,&map_h);
map_w=map_h=6;
for (i=0;i<map_h;i++)
//fgets(&map[i][0],map_w+1,f);
//fclose(f);
start_x=-1,end_x=-1;
for (i=0;i<map_h;i++)
for (j=0;j/*designde by 1wangxiaobo@163.com*/<map_w;j++) {
if (map[i][j]=='s') map[i][j]=' ',start_x=j,start_y=i;
if (map[i][j]=='e') map[i][j]=' ',end_x=j,end_y=i;
}
assert(start_x>=0 && end_x>=0);
//printf("%d,%d,%d,%d",start_x,start_y,end_x,end_y);
}
void showmap()
{
int i,j;
system("cls");
for (i=0;i<map_h;i++) {
gotoxy(1,i+1);
for (j=0;j<map_w;j++)
if (map[i][j]!=' ') printf("x");
else printf(" ");
}
gotoxy(end_x+1,end_y+1);
printf("e");
gotoxy(start_x+1,start_y+1);
printf("s");
}
int main()
{
?system(" A*算法試驗程序");//設置cmd窗口標題
?printf("………… A*算法試驗程序，…………");
int path[MAXINT];
readmap();
showmap();
Sleep(2000);
findpath(path);
printpath(path);
getchar();
system("pause");
return 0;
}
END


為了使的程序可以慢慢的打印出來動態的運行效果 加了Sleep(2000);
================

BP神經網絡C語言程序 ?

BP的C語言版，


#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
#include<time.h>


#define MAXWEIGHT ? ((float)0.3)
#define SCALEWEIGHT ((float)32767)
#define nInputNodes ? 4 ? ?
#define nHiddenNodes ?8 ? ?
#define nOutputNodes ?3 ??
#define nPatterns ? ? 15
#define nIterations ? 5000


#define ESC ? ? ? ? ? 27
#define ERRORLEVEL ? ?0.0001
#define ITEMS ? ? ? ? 8


typedef ?float *PFLOAT;
typedef ?PFLOAT VECTOR;
typedef ?PFLOAT *MATRIX;


void ? ? VectorAllocate(VECTOR *vector,int nCols);
void ? ? AllocateCols(PFLOAT matrix[],int nRows,int nCols);
void ? ? MatrixAllocate(MATRIX *pmatrix,int nRows,int nCols);
void ? ? MatrixFree(MATRIX matrix,int nRows);


MATRIX ? out0;
MATRIX ? out1;
MATRIX ? delta1;
MATRIX ? delw1;
MATRIX ? w1;
MATRIX ? out2;
MATRIX ? delta2;
MATRIX ? delw2;
MATRIX ? w2;
MATRIX ? target;
//VECTOR ? PatternID;


void ?main()
{
? ? ? ? ?float eta ?=0.15,
? ? ? ? ? ? ? ?alpha=0.075;
? ? ? ? ?int nReportErrors=100;
? ? ? ? ?float ErrorLevel=ERRORLEVEL;
? ? ? ? ?char ?MonitorError=0;
? ? ? ? ?float error;
? ? ? ? ?register int h;
? ? ? ? ?register int i;
? ? ? ? ?register int j;
? ? ? ? ?int ? ?p,
? ? ? ? ? ? ? ? q;
// ? ? ? ? ? ? ? ?r;
? FILE ? *fpPattern,
? ? ? ? ? ? *fpWeightsOut,
? ? ? ? ? ? *fpResults,
? ? ? ? ? ? *fpError,
? ?*fpTest;
? ?
??
? ? ? ? MatrixAllocate(&out0, ?nPatterns, ? nInputNodes);
? ? ? ? MatrixAllocate(&out1, ?nPatterns, ? nHiddenNodes);
? ? ? ? MatrixAllocate(&out2, ?nPatterns, ? nOutputNodes);
? ? ? ? MatrixAllocate(&delta2,nPatterns, ? nOutputNodes);
? ? ?MatrixAllocate(&delw2, nOutputNodes, nHiddenNodes+1);
? ? ?MatrixAllocate(&w2, ? ?nOutputNodes, nHiddenNodes+1);
? ? ? ? MatrixAllocate(&delta1, nPatterns, ? nHiddenNodes);
? ? ?MatrixAllocate(&delw1, nHiddenNodes,nInputNodes+1);
? ? ?MatrixAllocate(&w1, ? ?nHiddenNodes,nInputNodes+1);
? ? ? ? MatrixAllocate(&target,nPatterns, ? nOutputNodes);
// ? ? VectorAllocate(&PatternID,nPatterns);
//初始化權值----------------------------------
? ?srand((unsigned)time(NULL));
? ? ? ? ? ?
? ?for(h=0;h<nHiddenNodes;h++)
? ?{
? ? ? for(i=0;i<=nInputNodes;i++)
? ? ? {
? ? ? ? ? ? float frand=rand();
? ? ? ? ? ? ?w1[h][i]=MAXWEIGHT*(1.0-2*frand/SCALEWEIGHT);
? ? ? ? delw1[h][i]=0.0;


? ?}
? ?}
? ? for(j=0;j<nOutputNodes;j++)
? ? ? for(h=0;h<=nHiddenNodes;h++)
? ?{
? ? ? ? ? ?float frand=rand();
? ? ? ? ? ?w2[j][h]=MAXWEIGHT*(0.1-2*frand/SCALEWEIGHT);
? ? ? ? ? ?delw2[j][h]=0.0;


? ?}
? ??
//輸入訓練樣本-------------------------------
? ?if(fpPattern=fopen("input.txt","r"))
? ?for (p=0;p<nPatterns;p++)
? ? ? for (i=0;i<nInputNodes;i++)
? fscanf(fpPattern,"%f",&out0[p][i]);?
??
? ? for (p=0;p<nPatterns;p++)
? ? ? for (i=0;i<nOutputNodes;i++)
? fscanf(fpPattern,"%f",&target[p][i]);?
? ?
? ? ?fpError=fopen("error.txt","w");
? ??
//開始訓練--------------------------------
? fprintf(stderr,nIterations>1 ? "Training...\n":"Testing\n");
? ?for(q=0;q<nIterations;q++)
? ?{
? ? ? for (p=0;p<nPatterns;p++)
? ? ? ?{
? ? ? ? for (h=0;h<nHiddenNodes;h++)
? ? ? ? {
? ? ? ? float ?sum=w1[h][nInputNodes];
? ? ? ? ? ?for (i=0;i<nInputNodes;i++)
? ? ? ? ? ? ? ?sum+=w1[h][i]*out0[p][i];
? ? ? ? ? ?out1[p][h]=1.0/(1.0+exp(-sum));
? ? ? ? }


? ? ? ? for(j=0;j<nOutputNodes;j++)
? ? ? ? {
? ? ? ? ? ?float sum=w2[j][nHiddenNodes];
? ? ? ? ? ?for(h=0;h<nHiddenNodes;h++)
? ? ? ?sum+=w2[j][h]*out1[p][h];
? ? ? ? ? ?out2[p][j]=1.0/(1.0+exp(-sum));
? ? ? ? }
? ? ? ? for(j=0;j<nOutputNodes;j++)
? ? ? ? ? ?delta2[p][j]=(target[p][j]-out2[p][j])*
? ? out2[p][j]*(1.0-out2[p][j]);
? ? ? ? for(h=0;h<nHiddenNodes;h++)
? ? ? ? {
? ? ? ? ? ?float sum=0.0;
? ? ? ? ? ?for(j=0;j<nOutputNodes;j++)
? ? ? ? ? ? ? sum+=delta2[p][j]*w2[j][h];
? ? delta1[p][h]=sum*out1[p][h]*(1.0-out1[p][h]);
? ? ? ? }
? ? }///for p
? ? for(j=0;j<nOutputNodes;j++)
? ? {
? ? ? ?float dw;
? ? ? ?float sum=0.0;
? ? ? ?for(p=0;p<nPatterns;p++)
? ? ? ? ? sum+=delta2[p][j];
? ? ? ?dw=eta*sum+alpha*delw2[j][nHiddenNodes];
? ? ? ?w2[j][nHiddenNodes]+=dw;
? ? ? ?delw2[j][nHiddenNodes]=dw;
? ? ? ?for(h=0;h<nHiddenNodes;h++)
? ? ? ?{
? ? ? ? ? float sum=0.0;
? ? ? ? ? for(p=0;p<nPatterns;p++)
? ? ? sum+=delta2[p][j]*out1[p][h];
? ? ? ? ? dw ? ? ? ?=eta*sum+alpha*delw2[j][h];
? ? ? ? ? w2[j][h] ?+=dw;
? ? ? ? ? delw2[j][h]=dw;
? ? ? ?}
? ? }
? ? for(h=0;h<nHiddenNodes;h++)
? ? {
? ? ? ?float dw;
? ? ? ?float sum=0.0;
? ? ? ?for(p=0;p<nPatterns;p++)
? ? ? ? ? sum+=delta1[p][h];
? ? ? ?dw ? ? ?=eta*sum+alpha*delw1[h][nInputNodes];
? ? ? ?w1[h][nInputNodes]+=dw;
? ? ? ?delw1[h][nInputNodes]=dw;
? ? ? ?for(i=0;i<nInputNodes;i++)
? ? ? ?{
? ? ? ? ? float sum=0.0;
? ? ? ? ? for(p=0;p<nPatterns;p++)
? ? ? ? ? ? ?sum+=delta1[p][h]*out0[p][i];


? ? ? ?dw=eta*sum+alpha*delw1[h][i];
? ? ? ? ? w1[h][i]+=dw;
? ? ? ? ? delw1[h][i]=dw;
? ? ? ?}
? ? }
? ? if(kbhit())
? ? {
? ? ? ?int c=_getch();
? ? ? ?if((c=toupper(c))=='E')
? ? ? ? ? MonitorError++;
? ? ? ?else if(c==ESC)
? ? ? ? ? ?break;
? ? } ?
? ? if(MonitorError||(q%nReportErrors==0))
? ? {
? ? ? for(error=0.0,p=0;p<nPatterns;p++)
? ? ? {
? ? ? ? ?for(j=0;j<nOutputNodes;j++)
? ?{
? ? ? ? ? ?float temp=target[p][j]-out2[p][j];
? ? ? ? ? ?error+=temp*temp;
? ?}
? ?}
? ? error/=(nPatterns*nOutputNodes);
? ? fprintf(stderr,"Iteration %5d/%-5d Error %f\r",
? ? ? ? ? ? ?q,nIterations,error);
? ? MonitorError=0;
? ? if(q% nReportErrors==0)
? ? ?fprintf(fpError,"%d %f\n",q,error);
? ? if(error<ErrorLevel)
? ? ? break;
? ? }
? }//q
? for(p=0,error=0.0;p<nPatterns;p++)
? {
? ? for(j=0;j<nPatterns;j++)
? ? {
? ? ? ?float temp=target[p][j]-out2[p][j];
? ? ? ?error+=temp*temp;
? ? }
? }
? error/=(nPatterns*nOutputNodes);
? fprintf(stderr,"Iteration %5d/%-5d Error %f\n",q,nIterations,error);
? fprintf(fpError,"\n%d %f\n",q,error);
? fclose(fpError);


? //輸出權值-------------------------------
? if((fpWeightsOut=fopen("WeightsOut.txt","w"))==NULL)
? {
? ? ?fprintf(stderr,"can't write file %s\n","WeightsOut.txt");
? ? ?exit(1);
? }
? for(h=0;h<nHiddenNodes;h++)
? ? ? for(i=0;i<=nInputNodes;i++)
? ? ? ? fprintf(fpWeightsOut,"%g%c",w1[h][i],i%ITEMS==ITEMS-1?'\n':' ');
? for(j=0;j<nOutputNodes;j++)
? ? ? for(h=0;h<nHiddenNodes;h++)
? ? ? ? fprintf(fpWeightsOut,"%g%c",w2[j][h],j%ITEMS==ITEMS-1?'\n':' ');
? fclose(fpWeightsOut);


//輸出訓練結果----------------------------------------
? if((fpResults=fopen("Results.txt","w"))==NULL)
? {
? ? fprintf(stderr,"can't write file %s\n","Results.txt");
? ? fpResults=stderr;
? }
? for(p=0;p<nPatterns;p++)
? {
? ? ? fprintf(fpResults,"%d ",p+1);
? ? ? for(j=0;j<nOutputNodes;j++)
? ? ? ? ?fprintf(fpResults,"%f ",target[p][j]);
? ?fprintf(fpResults," -- ?");


? ? ? for(j=0;j<nOutputNodes;j++)
? ? ? ? ?fprintf(fpResults,"%f ",out2[p][j]);
? ?fprintf(fpResults,"\n");
? }
? fclose(fpResults);


//--測試數據--------------------------
?printf("Training has complete!\n1.Test data\n2.Exit\n");
? {
? ?
? ?int c=getchar();
? ?if(c=='1')?
? ? {
? ? char ftest[64];
? ? int testnum;
? printf("Please input file name of data!\n");
test:
? scanf("%s",&ftest);
? if((fpTest=fopen(ftest,"r"))==NULL)
? {
? ?printf("This file %s is not exist",ftest);
? ?goto test;
? }
? fscanf(fpTest,"%d",&testnum);
? ? ? ? printf("The result of you testing is:\n");
? for(p=0;p<testnum;p++)
? {
? printf("%d : ",p+1);
? for(h=0;h<nInputNodes;h++)
? ?fscanf(fpTest,"%f",&out0[0][h]);


? ? ? ? for (h=0;h<nHiddenNodes;h++)
? ? ? ? {
? ? ? ? float ?sum=w1[h][nInputNodes];
? ? ? ? ? ?for (i=0;i<nInputNodes;i++)
? ? ? ? ? ? ? ?sum+=w1[h][i]*out0[0][i];
? ? ? ? ? ?out1[0][h]=1.0/(1.0+exp(-sum));
? ? ? ? }
? ? ? ? ? ?
? ? ? ? for(j=0;j<nOutputNodes;j++)
? ? ? ? {
? ? ?float sum=w2[j][nHiddenNodes];
? ? ? ? ? ?for(h=0;h<nHiddenNodes;h++)
? ? ? ?sum+=w2[j][h]*out1[0][h];
? ? ? ? ? ?out2[0][j]=1.0/(1.0+exp(-sum));
? ? ?printf("%f ",out2[0][j]);
? }
? printf("\n");
? }
? ?}
? }?
? MatrixFree(out0, ?nPatterns);
? MatrixFree(out1, ?nPatterns);
? MatrixFree(delta1,nPatterns); ? ? ?
? MatrixFree(delw1, nHiddenNodes); ? ? ? ? ? ? ? ? ? ? ? ? ??
? MatrixFree(w1, ? ?nHiddenNodes);
? MatrixFree(out2, ?nPatterns);
? MatrixFree(delta2,nPatterns);
? MatrixFree(delw2, nOutputNodes);
? MatrixFree(w2, ? ?nOutputNodes);
? MatrixFree(target,nPatterns);
??
? }


? /*---------------變量分配空間------------------------*/
? void VectorAllocate(VECTOR *vector,int nCols)
? {
? ? ?if((*vector=(VECTOR)calloc(nCols,sizeof(float)))==NULL)
? ? ? {
? ? ? ? fprintf(stderr,"Sorry!Not enough memory for nodes\n");
? ? ? ? exit(1);
? ? ? }
? }
? void AllocateCols(PFLOAT matrix[],int nRows,int nCols)
? {
? ? ?int i;
? ? ?for(i=0;i<nRows;i++)
? ? ? ?VectorAllocate(&matrix[i],nCols);
? }
? void MatrixAllocate(MATRIX *pmatrix,int nRows,int nCols)
? {
? ? ?if((*pmatrix=(MATRIX)calloc(nRows,sizeof(PFLOAT)))==NULL)
? ? ?{
? ? ? ?fprintf(stderr,"Sorry!Not enough memory for nodes\n");
? ? ? ?exit(1);
? ? ?}
? ? ?AllocateCols(*pmatrix,nRows,nCols);
? }
? void MatrixFree(MATRIX matrix,int nRows)
? {
? ? ?int i;
? ? ?for(i=0;i<nRows;i++)
? ? ? ? free(matrix[i]);
? ? ?free(matrix);
? }
================

BP神經網絡-- C語言實現

C語言來實現一個簡單的單隱藏層的BP神經網絡，對于其他C類語言（C#、JAVA等）只需對本文中的代碼稍作修改即可移植。
?


一些數據的定義
? ?首先，我們介紹些下文中描述的程序里面的一些重要數據的定義。


#define Data ?820
#define In 2
#define Out 1
#define Neuron 45
#define TrainC 5500
? ? ? Data 用來表示已經知道的數據樣本的數量，也就是訓練樣本的數量。In 表示對于每個樣本有多少個輸入變量; Out 表示對于每個樣本有多少個輸出變量。Neuron 表示神經元的數量，TrainC 來表示訓練的次數。再來我們看對神經網絡描述的數據定義，來看下面這張圖里面的數據類型都是 double 型。


? ? ? d_in[Data][In] 存儲 Data 個樣本，每個樣本的 In 個輸入。d_out[Data][Out] 存儲 Data 個樣本，每個樣本的 Out 個輸出。我們用鄰接表法來表示 圖1 中的網絡，w[Neuron][In] ?表示某個輸入對某個神經元的權重，v[Out][Neuron] 來表示某個神經元對某個輸出的權重；與之對應的保存它們兩個修正量的數組 dw[Neuron][In] 和 dv[Out][Neuron]。數組 o[Neuron] 記錄的是神經元通過激活函數對外的輸出，OutputData[Out] ?存儲BP神經網絡的輸出。


?


程序的執行過程
? ? ? ? ?在這里，先不考慮具體函數的執行細節，從大體上來介紹程序的執行過程。用偽代碼來表示，具體的內容后面一步步介紹，如下：




主函數main{


　　　　讀取樣本數據 readData()；
? ? ? ?初始化BP神經網絡 ?initBPNework(){


? ? ? ? ? ? 包括數據的歸一，神經元的初始化 w[Neuron][In]、v[Out][Neuron]等；
? ? ? ? }
? ? ? ? BP神經網絡訓練 trainNetwork(){
? ? ? ? ? ? do{
? ? ? ? ? ? ? ? for（i 小于 樣本容量 Data）{
? ? ? ? ? ? ? ? ? ??
　　　　　　　　　　　　計算按照第 i 個樣本輸入，產生的BP神經網絡的輸出 computO(i)；
? ? ? ? ? ? ? ? ? ? 累記誤差精度；
? ? ? ? ? ? ? ? ? ? 反饋調節BP神經網絡中的神經元，完成第 i 個樣本的學習 backUpdate(i)；
? ? ? ? ? ? ? ? }
? ? ? ? ? ? }while（達到訓練次數 或者 符合誤差精度）；
? ? ? ? }


? ? ? ? 存儲訓練好的神經元信息 ?writeNeuron()；
? ? ? ? 用一些數據來測試，訓練出來的BP神經網絡的結果；
? ? ? ? return 0；
}


? ? ? ?以上是處理的流程，對于讀取數據、保存數據之類的處理本文將略去這方面內容，突出主干部分。


?


初始化BP神經網絡
? ? ? 初始化主要是涉及兩個方面的功能，一方面是對讀取的訓練樣本數據進行歸一化處理，歸一化處理就是指的就是將數據轉換成0~1之間。在BP神經網絡理論里面，并沒有對這個進行要求，不過實際實踐過程中，歸一化處理是不可或缺的。因為理論模型沒考慮到，BP神經網絡收斂的速率問題，一般來說神經元的輸出對于0~1之間的數據非常敏感，歸一化能夠顯著提高訓練效率?？梢杂靡韵鹿絹韺ζ溥M行歸一化，其中 加個常數A 是為了防止出現 0 的情況（0不能為分母）。


? ? ? ?y=(x-MinValue+A)/(MaxValue-MinValue+A)


? ? ? 另一方面，就是對神經元的權重進行初始化了，數據歸一到了（0~1）之間，那么權重初始化為（-1~1）之間的數據，另外對修正量賦值為0。實現參考代碼如下：




void initBPNework(){


? ? int i,j;
　　 /*
　　　　找到數據最小、最大值
　　　*/
? ? for(i=0; i<In; i++){
? ? ? ? Minin[i]=Maxin[i]=d_in[0][i];
? ? ? ? for(j=0; j<Data; j++)
? ? ? ? {
? ? ? ? ? ? Maxin[i]=Maxin[i]>d_in[j][i]?Maxin[i]:d_in[j][i];
? ? ? ? ? ? Minin[i]=Minin[i]<d_in[j][i]?Minin[i]:d_in[j][i];
? ? ? ? }
? ? }
? ? for(i=0; i<Out; i++){
? ? ? ? Minout[i]=Maxout[i]=d_out[0][i];
? ? ? ? for(j=0; j<Data; j++)
? ? ? ? {
? ? ? ? ? ? Maxout[i]=Maxout[i]>d_out[j][i]?Maxout[i]:d_out[j][i];
? ? ? ? ? ? Minout[i]=Minout[i]<d_out[j][i]?Minout[i]:d_out[j][i];
? ? ? ? }
? ? }
? ? /*
　　　　歸一化處理
　　　　*/
? ? for (i = 0; i < In; i++)
? ? ? ? for(j = 0; j < Data; j++)
? ? ? ? ? ? d_in[j][i]=(d_in[j][i]-Minin[i]+1)/(Maxin[i]-Minin[i]+1);
? ? for (i = 0; i < Out; i++)
? ? ? ? for(j = 0; j < Data; j++)
? ? ? ? ? ? d_out[j][i]=(d_out[j][i]-Minout[i]+1)/(Maxout[i]-Minout[i]+1);
? ? /*
　　　　初始化神經元
　　*/
? ? for (i = 0; i < Neuron; ++i) ? ?
? ? ? ? for (j = 0; j < In; ++j){ ? ?
? ? ? ? ? ? w[i][j]=(rand()*2.0/RAND_MAX-1)/2;
? ? ? ? ? ? dw[i][j]=0;
? ? ? ? }
? ? for (i = 0; i < Neuron; ++i) ? ?
? ? ? ? ?for (j = 0; j < Out; ++j){
? ? ? ? ? ? ?v[j][i]=(rand()*2.0/RAND_MAX-1)/2;
? ? ? ? ? ? ? dv[j][i]=0;
? ? ? ? ?}
}


?
BP神經網絡訓練
? ? ? 這部分應當說是整個BP神經網絡形成的引擎，驅動著樣本訓練過程的執行。由BP神經網絡的基本模型知道，反饋學習機制包括兩大部分，一是BP神經網絡產生預測的結果，二是通過預測的結果和樣本的準確結果進行比對，然后對神經元進行誤差量的修正。因此，我們用兩個函數來表示這樣的兩個過程，訓練過程中還對平均誤差 e 進行監控，如果達到了設定的精度即可完成訓練。由于不一定能夠到達預期設定的精度要求，我們添加一個訓練次數的參數，如果次數達到也退出訓練。實現參考代碼如下：


?




void ?trainNetwork(){
? ? int i,c=0;
? ? do{
? ? ? ? e=0;
? ? ? ? for (i = 0; i < Data; ++i){
? ? ? ? ? ? computO(i);
? ? ? ? ? ? e+=fabs((OutputData[0]-d_out[i][0])/d_out[i][0]);
? ? ? ? ? ? backUpdate(i);
? ? ? ? }
? ? ? ? //printf("%d ?%lf\n",c,e/Data);
? ? ? ? c++;
? ? }while(c<TrainC && e/Data>0.01);
}


?


? ? ? ? 其中的函數，computO(i) （O是output縮寫）計算BP神經網絡預測第 i 個樣本的輸出也就是第一個過程。backUpdate(i) 是根據預測的第 i 個樣本輸出對神經網絡的權重進行更新，e用來監控誤差。


　　 ?


================

總結

以上是生活随笔為你收集整理的人工智能、应用、程序的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。