beta演算法

1. LDA演算法裡面Dirichlet分布的兩個參數alpha和beta怎樣確定

LDA演算法裡面Dirichlet分布的兩個參數alpha和beta怎樣確定
利用sqoop將數據從MySQL導入到HDFS中,利用mahout的LDA的cvb實現對輸入數據進行聚類,並將結果更新到資料庫中。數據流向圖如下

mahout演算法分析

輸入數據格式
為<IntegerWritable, VectorWritable>的matrix矩陣,key為待聚類文本的數字編號，value為待聚類文本的單詞向量Vector, Vector的index為單詞在字典中的編號, value為TFIDF值。

演算法相關參數詳解(不包含hadoop運行參數)
項目中所有參數設置均與mahout-0.9目錄下的examples/bin/cluster-reuters.sh的147-172行設置一樣，即
$SCOUT cvb -i ${WORK_DIR}/${ROWID_MATRIX_DIR}/matrix -o ${WORK_DIR}/${LDA_DIR} -k 20 -ow -x 20 -dict ${WORK_DIR}/${DICTIONARY_FILES} -dt ${WORK_DIR}/${LDA_TOPICS_DIR} -mt ${WORK_DIR}/${LDA_MODEL_DIR}

input -- 輸入數據的hdfs路徑,這里是/home/hadoop-user/scout_workspace/scout/dataset/reuters-out-matrix-debug/matrix
dt -- 文檔主題輸出路徑,保存了每個文檔的相應topic的概率,這里是/home/hadoop-user/scout_workspace/scout/dataset/reuters-lda-topics
mt -- model的路徑,這里是/home/hadoop-user/scout_workspace/scout/dataset/reuters-lda-debug
k -- number of topics to learn,這里設置成20
x -- 模型迭代次數,也就是需要多少次迭代來生成最後的Model,默認值20
seed -- Random seed,生成初始readModel時的種子,默認值System.nanoTime() % 10000
dict -- 字典路徑,這里是/home/hadoop-user/scout_workspace/scout/dataset/reuters-out-seqdir-sparse-lda/dictionary.file-*
a -- Smoothing for document/topic distribution, document/topic分布的平滑系數,默認為1.0E-4
e -- Smoothing for topic/term distribution, topic/term分布的平滑系數,默認為1.0E-4
關於a和e,根據描述,a和e的合適取值為k/50(k為topic數量),但是這個網頁還保留著mahout ldatopics的命令介紹,而mahout 0.8,0.9均沒有該命令,推測應該是比較陳舊的內容,因此還是根據cluster-reuters.sh中的設置來，也就是採取默認值。
mipd -- 這個參數非常重要，對於每個文檔程序是先用RandomSeed來生成一個初始的readModel然後進行mipd次迭代，算出最終的model進行更新，這里選默認值10次

2. beta剪枝是相對於什麼節點而言的

beta剪枝是相對於極大極小節點而言。

Alpha-beta剪枝是一種搜索演算法，用以減少極小化極大演算法（Minimax演算法）搜索樹的節點數。這是一種對抗性搜索演算法，主要應用於機器遊玩的二人游戲（如井字棋、象棋、圍棋）。

當演算法評估出某策略的後續走法比之前策略的還差時，就會停止計算該策略的後續發展。該演算法和極小化極大演算法所得結論相同，但剪去了不影響最終決定的分枝。

注意：

Alpha-beta的優點是減少搜索樹的分枝，將搜索時間用在「更有希望」的子樹上，繼而提升搜索深度。該演算法和極小化極大演算法一樣，都是分支限界類演算法。若節點搜索順序達到最佳優化或近似最佳優化（將最佳選擇排在各節點首位），則同樣時間內搜索深度可達極小化極大演算法的兩倍多。

在（平均或恆定）分枝因子為b，搜索深度為d層的情況下，要評估的最大（即招法排序最差時）葉節點數目為O(b*b*...*b) =O(b)——即和簡單極小化極大搜索一樣。若招法排序最優（即始終優先搜索最佳招法），則需要評估的最大葉節點數目按層數奇偶性，分別約為O(b*1*b*1*...*b)和O(b*1*b*1*...*1)（或O(b) =O(√b)）。

其中層數為偶數時，搜索因子相當於減少了其平方根，等於能以同深度搜索兩次。b*1*b*1*...意義為，對第一名玩家必須搜索全部招法找到最佳招式，但對於它們，只用將第二名玩家的最佳招法截斷——alpha-beta確保無需考慮第二名玩家的其他招法。但因節點生成順序隨機，實際需要評估的節點平均約為O(b)。

3. 高斯－馬爾可夫定理 以及為什麼最小二乘法是最佳線性無偏估計

在做機器學習和線性回歸的時候，經常會遇到不講道理的最小二乘法，優化的目標是(yi-y)^2最小，這個結論非常暴力，為啥不是三次方，四次方，他的來源是什麼呢？
本文參考的內容 高斯馬爾科夫定理的證明

在 統計學 中， 高斯－馬爾可夫定理(Gauss-Markov Theorem) 陳述的是：在 線性回歸 模型中，如果誤差滿足零 均值 、 同方差 且 互不相關 ，則回歸系數的最佳線性 無偏 估計 ( BLUE , Best Linear unbiased estimator)就是 普通最小二乘法估計 。

上面的理論言簡意賅，但是很多名詞的意思需要展開來理解。
1、什麼是線性回歸？
2、為什麼要零均值、同方差、互不相關
3、什麼是線性估計，什麼是無偏估計？
4、什麼是最佳估計，標準是什麼？

回歸就是利用測量到的數據去嘗試計算真實值得一種方法，假設我們測量到了很多的數據，但是我們內心覺得這些數據可能是有線性關系的，那麼我們可以利用這些數據去計算（估計）那條真實的「直線」。

線性回歸有一些問題值得思考：

這個比較好理解，每一次測量，肯定是存在誤差的，如果這個誤差的均值是0，形象的理解就是誤差可能大一點、也可能小一點，平均起來就是在真值附近變化，而且每次測量的行為都是獨立互不影響的。我們就可以定義這個誤差的期望是0，方差是一個固定值。

我們也不知道真實值，對誤差的這種假設其實一種理想的假設。

線性估計的模型是這樣的，beta是一個模型的真實值，他的維度是k維向量，X是我們的樣本，他是一個N*K的矩陣，y是我們樣本的結果，是一個N維矩陣，epsilon是我們每次測量和真實值的誤差。

比如我現在測量了N個學生的身高、體重、起床時間、平時作業成績。。。。等等這些參數（K個參數），我想知道這些參數和他們的期末考試成績的線性關系是什麼，他們的期末成績就是y（N維向量），我現在需要估計的beta就是每個參數和期末成績關系的矩陣。這個方程裡面y和x是已知的。

如果N=K，那麼這就是一個N元N次方程組，他只有一個解，我們用這個解就能得到一個beta。但是實際情況來說我們可以測量很多學生的值，N可以比K大很多，這種情況下方程組是無解的。（直觀理解，那些點並不完全在一條直線、一個平面上）

在這種情況下我需要一種演算法去計算一個beta的估計：

這里的C應該是和x有關系的。但是這個C可以有很多形式，他就是一種線性估計

無偏估計的定義大概是這樣的：

看著很不直觀，但是可以這樣理解，無偏估計的意思是我抽取一批樣本，然後根據這些樣本估計出來的beta，是在真實beta的任意方向等可能存在的，直接一點來說，我把很多批次的估計再來求取一個平均，會更接近於真實的beta，在做無窮多次抽取之後可以任認為這些估計的均值就是真實值。

具體的例子：比如我們要估計總體均值theata，隨機抽取一批數據得到樣本的均值，這個均值就是無偏的，隨著抽取的批次增加，E(E(x)) = theata，也就是均值的均值會得到真實值。

有偏估計是指這個估計的過程中引入了一些系統的誤差，最終把很多批次的估計合計起來看，得不到真實的結果。

還有一個和無偏相關的概念——一致性：

關於無偏和一致性這篇文章講得比較好 深入淺出講解數理統計——（3）評價估計量的好壞

總結來說：

實際上真實世界中的測量都是有系統誤差的，估計出來的值是有偏的，但是如果這個偏差比較小，而且是一致的，那麼這個估計量就是有意義的。反之，就算這個估計是無偏的，但是沒有一致性，那麼只有在窮舉之後才能得到那個真實值，這樣的估計也是很不好的。

再重復一下開始的假設，在證明過程中，參數都是矩陣形式的、設計到矩陣運算的和矩陣的性質。

現在我們要估計K個系統中的參數，他們組成一個K維向量beta。
OLS（最小二乘法）的估計結果由上圖所示，現在的目標就是要證明OLS估計是最佳的

證明如下，帶入y，右邊出現真值beta，由於epsilon是0均值的，所以OSL估計出來的beta就是真值beta

估計beta的方法有很多種，我們定義最好的一種是，方差最小的，所以最小二乘法是平方而不是三次方、四次方。

也就是說上式中左邊的估計方法要優於右邊的估計方法，接下來就是證明為什麼OSL最小二乘法的方差是最小的

要證明4.2中的不等式成立，那就是要證明下式是 半正定矩陣

假設一個任意的估計矩陣是C，那麼這個估計矩陣和OSL的估計矩陣的差異，設為D矩陣，由於兩個beta都是無偏估計，那麼有：D矩陣性質是DX=0，這里有個條件概率E[DXbeta|X]，如果X是已知的，那麼DX只是一個常量，這個常量必須恆等於一個k*k的0矩陣

利用了一下這個性質：

4. pascal 中國象棋 Alpha-Beta演算法源程序及解釋

Alpha值代表的是發起走棋一方(期望極大值)做能接受的最小值,搜索極大值一方必須要找到一個比Alpha值更大的，否則這步棋就沒有任何意義
Beta值代表的是對手(期望極小值)所能接受的最壞值，搜索極小值的一方必須找到一個比Beta值更小的一步棋，否則也是沒意義的（因為有更好的一步棋已經生成了)

先看函數調用方式
int AlphaBeta(int depth, int alpha, int beta);

AlphaBeta(5, -INFINITE INFINITE);
這是發起走棋一方（搜索極大值的一方）調用的，因此設定為alpha為
-INFINITE；

這里假設是採用負極大值演算法的

int AlphaBeta(int depth, int alpha, int beta)
{
if(depth == 0 || IsGameOver()) return Evaluate(); //如果層數為0或者已達最終狀態則返回本步棋的估值
for(each possible move)
{
MakeMove();

int val = -AlphaBeta(depth - 1, -beta, -alpha);
UnMakeMove();

if(val >= beta)
{
return val;
//注意，這里需要返回val，因為上一層應該知道具體搜索到的值，以配合各種Alpha-Beta演算法的變種
}
if(val > alpha)
{
alpha = val;
...
//當然 這里還需要記錄這步最佳的走法
}

}
return alpha;//返回最好的值
}

首先假設是負極大演算法，
Alpha值是父節點（非root)能搜索到的最大值，任何比他小的值都沒意義。
Beta值是你所能找到的最壞的一種情況，任何比它大的都沒意義。
{
int val = -AlphaBeta(depth - 1, -beta, -alpha);
}
注意這個所謂的負極大的估值函數是估算本方的最優值，所以你的對手（子節點）估算出來的最優值如果大於你的-Beta
例如-beta == 3 子節點估值== 4，那麼他實際上返回後（取負得-4)是小於你的Beta,所以它是有意義的。再看這個-alpha,
實際上是本層的beta是上一層節點（對手)的最大值的負值，如果任何本層節點取值,例如-alpha == 3,子節點估值為4,
4 >= 3，那麼返回的是-4,-4< -3(alpha那個地方），所以無意義，因為在本層所有節點又都是越取越大（負極大），
所以本層也就沒必要找了，直接剪枝了

5. 【急】AlphaBeta演算法該怎麼理解

如果你覺得理解了思路但看不遞歸， 應該是說裡面的負值極大部分。

負值極大值搜索是極小極大值搜索的一個改進。它的返回值代表當前方是否占優，搜索中如果要使用子結點的返回值則需要加上負號，因為子結點的返回值表示子結點對對方是否占優。相比較極大極小值搜索，它並沒有帶來結果上的改變和效率上的優化，然而它使代碼更短，更方便維護。

其實這個就是負值極大和ab一起用的 過程中每層把alpha beta的值也顛倒過來並加負號 這個和ab的搜索思路無關 只是一個簡化代碼的技巧
如果您還是不懂 您可以寫一個不帶負值極大的ab搜索 那樣一般是分兩個函數寫 一個最大 一個最小

6. 10、填空在AlphaBeta剪枝演算法中,我們把一個結點可能取值的上界記作____值

這個問題問的不是很清楚，個人理解，在AlphaBeta剪枝演算法中，可以把一個節點可能取值的上界記作 Beta 值。
AlphaBeta剪枝演算法是對極大極小演算法的優化，效率更高。極大極小是一種暴力搜索策略，需要遍歷所有可能的情況，隨著節點數特別是深度的增加，演算法性能會大幅下降。AlphaBeta剪枝演算法採用遞歸的方式進行倒推估算，可以在搜索過程中剪除無用的分支，從而減少不必要的搜索（這些搜索中不會有滿足要求的答案），提升演算法的效率。
可以這樣簡單地理解吧，每一層的節點都有Alpha（下界）、Beta（上界），而且是動態調整的，如果在推導過程中發現 Alpha>=Beta，那麼就可以終止當前節點往下各層級的搜索，達到提高效率的目的。

7. python 井字棋 ALPHA-BETA剪枝演算法和暴力演算法 具體代碼

#!/usr/bin/env python
'''Tic tac toe in python, Minimax with alpha-beta pruning.'''
import sys
import random
import getopt

# Board: array of 9 int, positionally numbered like this:
# 0 1 2
# 3 4 5
# 6 7 8

# Well-known board positions
WINNING_TRIADS = ((0, 1, 2), (3, 4, 5), (6, 7, 8), (0, 3, 6), (1, 4, 7),
(2, 5, 8), (0, 4, 8), (2, 4, 6))
PRINTING_TRIADS = ((0, 1, 2), (3, 4, 5), (6, 7, 8))
# The order in which slots get checked for absence of a player's token:
SLOTS = (0, 1, 2, 3, 4, 5, 6, 7, 8)

# Internal-use values. Chosen so that the "winner" of a finished
# game has an appropriate value, as X minimizes and O maximizes
# the board's value (function board_valuation() defines "value")
# Internally, the computer always plays Os, even though the markers[]
# array can change based on -r command line flag.
X_token = -1
Open_token = 0
O_token = 1

# Strings for output: player's markers, phrase for end-of-game
MARKERS = ['_', 'O', 'X']
END_PHRASE = ('draw', 'win', 'loss')

HUMAN = 1
COMPUTER = 0

def board_valuation(board, player, next_player, alpha, beta):
'''Dynamic and static evaluation of board position.'''
# Static evaluation - value for next_player
wnnr = winner(board)
if wnnr != Open_token:
# Not a draw or a move left: someone won
return wnnr
elif not legal_move_left(board):
# Draw - no moves left
return 0 # Cat
# If flow-of-control gets here, no winner yet, not a draw.
# Check all legal moves for "player"
for move in SLOTS:
if board[move] == Open_token:
board[move] = player
val = board_valuation(board, next_player, player, alpha, beta)
board[move] = Open_token
if player == O_token: # Maximizing player
if val > alpha:
alpha = val
if alpha >= beta:
return beta
else: # X_token player, minimizing
if val < beta:
beta = val
if beta <= alpha:
return alpha
if player == O_token:
retval = alpha
else:
retval = beta
return retval

def print_board(board):
'''Print the board in human-readable format.
Called with current board (array of 9 ints).
'''
for row in PRINTING_TRIADS:
for hole in row:
print MARKERS[board[hole]],
print

def legal_move_left(board):
''' Returns True if a legal move remains, False if not. '''
for slot in SLOTS:
if board[slot] == Open_token:
return True
return False

def winner(board):
''' Returns -1 if X wins, 1 if O wins, 0 for a cat game,
0 for an unfinished game.
Returns the first "win" it finds, so check after each move.
Note that clever choices of X_token, O_token, Open_token
make this work better.
'''
for triad in WINNING_TRIADS:
triad_sum = board[triad[0]] + board[triad[1]] + board[triad[2]]
if triad_sum == 3 or triad_sum == -3:
return board[triad[0]] # Take advantage of "_token" values
return 0

def determine_move(board):
''' Determine Os next move. Check that a legal move remains before calling.
Randomly picks a single move from any group of moves with the same value.
'''
best_val = -2 # 1 less than min of O_token, X_token
my_moves = []
for move in SLOTS:
if board[move] == Open_token:
board[move] = O_token
val = board_valuation(board, X_token, O_token, -2, 2)
board[move] = Open_token
print "My move", move, "causes a", END_PHRASE[val]
if val > best_val:
best_val = val
my_moves = [move]
if val == best_val:
my_moves.append(move)
return random.choice(my_moves)

def recv_human_move(board):
''' Encapsulate human's input reception and validation.
Call with current board configuration. Returns
an int of value 0..8, the Human's move.
'''
looping = True
while looping:
try:
inp = input("Your move: ")
yrmv = int(inp)
if 0 <= yrmv <= 8:
if board[yrmv] == Open_token:
looping = False
else:
print "Spot already filled."
else:
print "Bad move, no donut."

except EOFError:
print
sys.exit(0)
except NameError:
print "Not 0-9, try again."
except SyntaxError:
print "Not 0-9, try again."

if looping:
print_board(board)

return yrmv

def usage(progname):
'''Call with name of program, to explain its usage.'''
print progname + ": Tic Tac Toe in python"
print "Usage:", progname, "[-h] [-c] [-r] [-x] [-X]"
print "Flags:"
print "-x, -X: print this usage message, then exit."
print "-h: human goes first (default)"
print "-c: computer goes first"
print "-r: computer is X, human is O"
print "The computer O and the human plays X by default."

def main():
'''Call without arguments from __main__ context.'''
try:
opts, args = getopt.getopt(sys.argv[1:], "chrxX",
["human", "computer", "help"])
except getopt.GetoptError:
# print help information and exit:
usage(sys.argv[0])
sys.exit(2)

next_move = HUMAN # Human goes first by default

for opt, arg in opts:
if opt == "-h":
next_move = HUMAN
if opt == "-c":
next_move = COMPUTER
if opt == "-r":
MARKERS[-1] = 'O'
MARKERS[1] = 'X'
if opt in ("-x", "-X", "--help"):
usage(sys.argv[0])
sys.exit(1)

# Initial state of board: all open spots.
board = [Open_token, Open_token, Open_token, Open_token, Open_token,
Open_token, Open_token, Open_token, Open_token]

# State machine to decide who goes next, and when the game ends.
# This allows letting computer or human go first.
while legal_move_left(board) and winner(board) == Open_token:
print
print_board(board)

if next_move == HUMAN and legal_move_left(board):
humanmv = recv_human_move(board)
board[humanmv] = X_token
next_move = COMPUTER

if next_move == COMPUTER and legal_move_left(board):
mymv = determine_move(board)
print "I choose", mymv
board[mymv] = O_token
next_move = HUMAN

print_board(board)
# Final board state/winner and congratulatory output.
try:
# "You won" should never appear on output: the program
# should always at least draw.
print ["Cat got the game", "I won", "You won"][winner(board)]
except IndexError:
print "Really bad error, winner is", winner(board)

sys.exit(0)
#-------
if __name__ == '__main__':
try:
main()
except KeyboardInterrupt:
print
sys.exit(1)

8. 微生物多樣研究—β多樣性分析

一、β-多樣性分析

1. 樣品間距離計算

樣品間的物種豐度分布差異程度可通過統計學中的距離進行量化分析，使用統計演算法Euclidean，Bray-Curtis，Unweighted_unifrac，weighted_unifrac等，計算兩兩樣品間距離，獲得距離矩陣，可用於後續進一步的beta多樣性分析和可視化統計分析。 ​

例如：將距離矩陣使用熱圖表示可直觀觀察樣品間的差異高低分布。

2. PCA 分析

主成分分析(PCA，PrincipalComponent Analysis)，是一種應用方差分解，對多維數據進行降維，從而提取出數據中最主要的元素和結構的方法。  

應用PCA分析，能夠提取出最大程度反映樣品間差異的兩個坐標軸，從而將多維數據的差異反映在二維坐標圖上，進而揭示復雜數據背景下的簡單規律。  

如果樣品的群落組成越相似，則它們在PCA圖中的距離越接近。

3.  PCoA分析

主坐標分析（PCoA，PrincipalCo-ordinates Analysis），是一種與PCA類似的降維排序方法，通過一系列的特徵值和特徵向量排序從多維數據中提取出最主要的元素和結構。  

可以基於bray_curtis、WeightedUnifrac距離和UnweightedUnifrac距離分別來進行PCoA分析，並選取貢獻率最大的主坐標組合進行作圖展示。  

如果樣品距離越接近，表示物種組成結構越相似，因此群落結構相似度高的樣品傾向於聚集在一起，群落差異很大的樣品則會遠遠分開。

※   當PCA或PCoA分析的前兩個成分（解釋度）較小（如pc1與pc2之和小於50%）時，可嘗試將前三個成分用於對假設因素進行驗證，並作三維圖來反應樣品間群落組成的關系。

4.  NMDS分析

非度量多維尺度分析（NMDS分析）是一種將多維空間的研究對象（樣品或變數）簡化到低維空間進行定位、分析和歸類，同時又保留對象間原始關系的數據分析方法。 

適用於無法獲得研究對象間精確的相似性或相異性數據，僅能得到他們之間等級關系數據的情形。

基本特徵是將對象間的相似性或相異性數據看成點間距離的單調函數，在保持原始數據次序關系的基礎上，用新的相同次序的數據列替換原始數據進行度量型多維尺度分析。換句話說，當資料不適合直接進行變數型多維尺度分析時，對其進行變數變換，再採用變數型多維尺度分析，對原始資料而言，就稱之為非度量型多維尺度分析。

特點是根據樣品中包含的物種信息，以點的形式反映在多維空間上，而對不同樣品間的差異程度，則是通過點與點間的距離體現的，最終獲得樣品的空間定位點圖。

5. 多樣品相似度樹狀圖

利用樹枝結構描述和比較多個樣品間的相似性和差異關系。 

首先使用描述群落組成關系和結構的演算法計算樣品間的距離，即根據beta多樣性距離矩陣進行層次聚類（Hierarchicalcluatering）分析，使用非加權組平均法UPGMA（Unweightedpair group method with arithmetic mean）演算法構建樹狀結構，得到樹狀關系形式用於可視化分析。

6.  PLS-DA分析

PLS-DA（PartialLeast Squares Discriminant Analysis）分析是以偏最小二乘回歸模型為基礎，作為一種有監督的模式識別方法，根據給定的樣品分布/分組信息，對群落結構數據進行判別分析。 

PLS-DA通過尋找物種豐度矩陣和給定的樣品分布/分組信息的最大協方差，從而在新的低維坐標系中對樣品重新排序。

PLS-DA可以減少變數間多重共線性產生的影響，因此，比較適合用於微生物群落數據的研究。

分析時，會計算每個物種的VIP（Variableimportance in projection）系數（VIP值需>1，值越大，說明該物種對於組間差異的貢獻越大）

7.組合（變換）分析圖

特點： 

集多種分析結果於一身組合成圖，即一整圖表解釋多種生物學意義。 

展現形式、分析名稱發生變化並進行重新調整，但所表述的生物學意義未變化。 

具有一定的觀賞性。

  分析形式多種多樣，但萬變不離其宗。

例如：樣本聚類樹與柱狀圖組合分析

9. alpha-beta搜索演算法思想（十萬火急）

博弈啊，我以前寫過，大致框架是：

int search(，顏色,deep,alpha,beta)
{
if(deep=最大搜索步數）
return 估值（局面，顏色）；
for(遍歷所有可行走法）
{
局面.走棋；
Score=-int search(局面，-顏色,deep+1,-beta,-alpha)
if(Score>=beta)
return(Score);
if(Score>alpha)
alpha=Score;
局面.撤銷走棋；
}
return 出現過的最大Score；
}

調用的時候是 search(局面，電腦的顏色,0,負無窮,正無窮),得到一個局面的評分

10. 貝塔系數怎麼計算 具體

貝塔系數的計算

貝塔系數利用回歸的方法計算。貝塔系數為1即證券的價格與市場一同變動。貝塔系數高於1即證券價格比總體市場更波動。貝塔系數低於1（大於0）即證券價格的波動性比市場為低。

貝塔系數的計算公式

公式為：

其中ρam為證券a與市場的相關系數；σa為證券a的標准差；σm為市場的標准差。

據此公式，貝塔系數並不代表證券價格波動與總體市場波動的直接聯系。

不能絕對地說，β越大，證券價格波動（σa）相對於總體市場波動（σm）越大；同樣，β越小，也不完全代表σa相對於σm越小。

甚至即使β = 0也不能代表證券無風險，而有可能是證券價格波動與市場價格波動無關（ρam= 0），但是可以確定，如果證券無風險（σa），β一定為零。

拓展資料

1、貝塔系數概述

貝塔系數（Beta Coefficient）是一種評估證券系統性風險的工具，用以度量一種證券或一個投資證券組合相對總體市場的波動性。在股票、基金等投資術語中常見。

貝塔系數是統計學上的概念，它所反映的是某一投資對象相對於大盤的表現情況。其絕對值越大，顯示其收益變化幅度相對於大盤的變化幅度越大；絕對值越小，顯示其變化幅度相對於大盤越小。如果是負值，則顯示其變化的方向與大盤的變化方向相反；

大盤漲的時候它跌，大盤跌的時候它漲。由於我們投資於投資基金的目的是為了取得專家理財的服務,以取得優於被動投資於大盤的表現情況，這一指標可以作為考察基金經理降低投資波動性風險的能力。 在計算貝塔系數時,除了基金的表現數據外,還需要有作為反映大盤表現的指標。

2、貝塔系數應用

貝塔系數反映了個股對市場（或大盤）變化的敏感性，也就是個股與大盤的相關性或通俗說的「股性」。可根據市場走勢預測選擇不同的貝塔系數的證券從而獲得額外收益，特別適合作波段操作使用。

當有很大把握預測到一個大牛市或大盤某個大漲階段的到來時，應該選擇那些高貝塔系數的證券，它將成倍地放大市場收益率，為你帶來高額的收益；相反在一個熊市到來或大盤某個下跌階段到來時，你應該調整投資結構以抵禦市場風險，避免損失，辦法是選擇那些低貝塔系數的證券。

為避免非系統風險，可以在相應的市場走勢下選擇那些相同或相近貝塔系數的證券進行投資組合。比如：一支個股貝塔系數為1.3，說明當大盤漲1%時，它可能漲1.3%，反之亦然；但如果一支個股貝塔系數為-1.3%時，說明當大盤漲1%時，它可能跌1.3%，同理，大盤如果跌1%，它有可能漲1.3%。

貝塔系數是反映單個證券或證券組合相對於證券市場系統風險變動程度的一個重要指標。通過對貝塔系數的計算,投資者可以得出單個證券或證券組合未來將面臨的市場風險狀況.通常貝塔系數是用歷史數據來計算的，而歷史數據計算出來的貝塔系數是否具有一定的穩定性，將直接影響貝塔系數的應用效果。利用CHOW檢驗方法對我國證券市場已經實現股份全流通的上市公司進行檢驗後發現，大部分上市公司在實現股份全流通後，其貝塔系數並沒有發生顯著的改變，用貝塔系數進行系統風險的預測可靠性還是相當高的。