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检验方法对我国证券市场已经实现股份全流通的上市公司进行检验后发现，大部分上市公司在实现股份全流通后，其贝塔系数并没有发生显着的改变，用贝塔系数进行系统风险的预测可靠性还是相当高的。